From 62eb9c682f1859bd33a7caba1e8b7a1e83b5c078 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Sat, 4 Jul 2026 02:20:28 -0400 Subject: [PATCH 1/5] Ixon: drop recr/refl/nested flags from Inductive Remove the `recr`/`refl` bools and the `nested` count from the Ixon `Inductive` constant and its serialization (Rust and Lean), and from the `Indc` reveal-proof variant, renumbering the field-presence mask bits. These flags are derivable from constructor structure, so storing them was redundant and trusting declared values was an adversarial surface (e.g. is_rec = false on a recursive inductive enables improper struct-eta). - kernel: KConst::Indc loses is_rec/is_refl/nested. is_rec is now computed on demand (computed_is_rec), memoized in the new env is_rec_cache with a provisional entry to break the whnf -> try_struct_eta_iota -> is_struct_like cycle. This replaces the declared-vs-computed H1 verification in check_inductive. - compile: new compute_lean_ind_flags recomputes Lean's block-wide isRec/isReflexive/numNested wherever an InductiveVal is reconstructed without a source Lean env (kernel egress, decompile), since Ixon no longer stores the flags; validate_lean_ind_flags checks a whole env against the recomputation. - tests/benchmarks: add AuxDedup1/AuxDedup2 mutual fixtures exercising aux-constant dedup across blocks (fix forthcoming); add a CompileMutualFixtures benchmark lib building the mutual test fixtures; ignore *.ixe. --- .gitignore | 1 + Benchmarks/Compile/CompileMutualFixtures.lean | 1 + Benchmarks/Compile/lake-manifest.json | 29 +- Benchmarks/Compile/lakefile.toml | 7 + Ix/Claim.lean | 34 +-- Ix/Commit.lean | 3 +- Ix/CompileM.lean | 6 - Ix/DecompileM.lean | 5 +- Ix/Ixon.lean | 15 +- Tests/Gen/Claim.lean | 3 +- Tests/Gen/Ixon.lean | 4 +- Tests/Ix/Compile/Mutual.lean | 21 ++ Tests/Ix/IxVM.lean | 3 +- Tests/Ix/Kernel/CheckEnv.lean | 1 + crates/compile/src/compile.rs | 9 - crates/compile/src/compile/aux_gen.rs | 3 - .../compile/src/compile/aux_gen/expr_utils.rs | 9 - crates/compile/src/compile/aux_gen/nested.rs | 213 ++++++++++++- .../compile/src/compile/aux_gen/recursor.rs | 5 - crates/compile/src/compile/env.rs | 14 +- crates/compile/src/decompile.rs | 54 +++- crates/compile/src/kernel_egress.rs | 89 +++--- crates/ffi/src/kernel.rs | 9 +- crates/ffi/src/lean.rs | 2 +- crates/ffi/src/lean_ixon/constant.rs | 24 +- crates/ixon/src/constant.rs | 9 - crates/ixon/src/proof.rs | 63 +--- crates/ixon/src/serialize.rs | 18 +- crates/kernel/src/canonical_check.rs | 14 +- crates/kernel/src/check.rs | 21 +- crates/kernel/src/congruence.rs | 7 +- crates/kernel/src/constant.rs | 6 - crates/kernel/src/def_eq.rs | 82 ++--- crates/kernel/src/env.rs | 8 +- crates/kernel/src/inductive.rs | 282 +++++++----------- crates/kernel/src/infer.rs | 54 ++-- crates/kernel/src/ingress.rs | 9 - crates/kernel/src/primitive.rs | 174 +++++------ crates/kernel/src/subst.rs | 2 +- crates/kernel/src/tc.rs | 8 +- crates/kernel/src/tutorial/defeq.rs | 36 --- crates/kernel/src/tutorial/inductive.rs | 54 ---- crates/kernel/src/tutorial/reduction.rs | 18 -- crates/kernel/src/whnf.rs | 53 ++-- 44 files changed, 713 insertions(+), 769 deletions(-) create mode 100644 Benchmarks/Compile/CompileMutualFixtures.lean diff --git a/.gitignore b/.gitignore index 563e7a4e..2ba25779 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ # Nix result* .direnv/ +*.ixe diff --git a/Benchmarks/Compile/CompileMutualFixtures.lean b/Benchmarks/Compile/CompileMutualFixtures.lean new file mode 100644 index 00000000..e1226de6 --- /dev/null +++ b/Benchmarks/Compile/CompileMutualFixtures.lean @@ -0,0 +1 @@ +import Tests.Ix.Compile.Mutual diff --git a/Benchmarks/Compile/lake-manifest.json b/Benchmarks/Compile/lake-manifest.json index 2134dbd6..7915fb72 100644 --- a/Benchmarks/Compile/lake-manifest.json +++ b/Benchmarks/Compile/lake-manifest.json @@ -21,6 +21,13 @@ "inputRev": "v4.29.0", "inherited": false, "configFile": "lakefile.toml"}, + {"type": "path", + "scope": "", + "name": "ix", + "manifestFile": "lake-manifest.json", + "inherited": false, + "dir": "../..", + "configFile": "lakefile.lean"}, {"url": "https://github.com/leanprover-community/plausible", "type": "git", "subDir": null, @@ -110,6 +117,26 @@ "manifestFile": "lake-manifest.json", "inputRev": null, "inherited": true, - "configFile": "lakefile.lean"}], + "configFile": "lakefile.lean"}, + {"url": "https://github.com/argumentcomputer/Blake3.lean", + "type": "git", + "subDir": null, + "scope": "", + "rev": "d15f36cf76eb5834b0e623e02b97fd4d95e56cc7", + "name": "Blake3", + "manifestFile": "lake-manifest.json", + "inputRev": "d15f36cf76eb5834b0e623e02b97fd4d95e56cc7", + "inherited": true, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/argumentcomputer/LSpec", + "type": "git", + "subDir": null, + "scope": "", + "rev": "d3c15b93a1dd4e7c8d5c0c3825c9555737e55c3e", + "name": "LSpec", + "manifestFile": "lake-manifest.json", + "inputRev": "d3c15b93a1dd4e7c8d5c0c3825c9555737e55c3e", + "inherited": true, + "configFile": "lakefile.toml"}], "name": "Compile", "lakeDir": ".lake"} diff --git a/Benchmarks/Compile/lakefile.toml b/Benchmarks/Compile/lakefile.toml index db404909..fa9bb4d8 100644 --- a/Benchmarks/Compile/lakefile.toml +++ b/Benchmarks/Compile/lakefile.toml @@ -17,6 +17,13 @@ name = "CompileMathlib" [[lean_lib]] name = "CompileFLT" +[[lean_lib]] +name = "CompileMutualFixtures" + +[[require]] +name = "ix" +path = "../.." + [[require]] name = "flt" git = "https://github.com/ImperialCollegeLondon/FLT" diff --git a/Ix/Claim.lean b/Ix/Claim.lean index 39e440a9..56f98205 100644 --- a/Ix/Claim.lean +++ b/Ix/Claim.lean @@ -94,10 +94,9 @@ structure RevealRecursorRule where inductive RevealMutConstInfo where | defn (kind : Option DefKind) (safety : Option DefinitionSafety) (lvls : Option UInt64) (typ : Option Address) (value : Option Address) - | indc (isRecr : Option Bool) (refl : Option Bool) (isUnsafe : Option Bool) - (lvls : Option UInt64) (params : Option UInt64) - (indices : Option UInt64) (nested : Option UInt64) - (typ : Option Address) (ctors : Option (Array (UInt64 × RevealConstructorInfo))) + | indc (isUnsafe : Option Bool) (lvls : Option UInt64) (params : Option UInt64) + (indices : Option UInt64) (typ : Option Address) + (ctors : Option (Array (UInt64 × RevealConstructorInfo))) | recr (k : Option Bool) (isUnsafe : Option Bool) (lvls : Option UInt64) (params : Option UInt64) (indices : Option UInt64) (motives : Option UInt64) (minors : Option UInt64) @@ -240,19 +239,15 @@ def put : RevealMutConstInfo → PutM Unit match lvls with | some n => putTag0 ⟨n⟩ | none => pure () match typ with | some a => Serialize.put a | none => pure () match value with | some a => Serialize.put a | none => pure () - | .indc isRecr refl isUnsafe lvls params indices nested typ ctors => do + | .indc isUnsafe lvls params indices typ ctors => do putU8 1 - let mask := computeMask [isRecr.isSome, refl.isSome, isUnsafe.isSome, - lvls.isSome, params.isSome, indices.isSome, - nested.isSome, typ.isSome, ctors.isSome] + let mask := computeMask [isUnsafe.isSome, lvls.isSome, params.isSome, + indices.isSome, typ.isSome, ctors.isSome] putTag0 ⟨mask⟩ - match isRecr with | some b => putBoolField b | none => pure () - match refl with | some b => putBoolField b | none => pure () match isUnsafe with | some b => putBoolField b | none => pure () match lvls with | some n => putTag0 ⟨n⟩ | none => pure () match params with | some n => putTag0 ⟨n⟩ | none => pure () match indices with | some n => putTag0 ⟨n⟩ | none => pure () - match nested with | some n => putTag0 ⟨n⟩ | none => pure () match typ with | some a => Serialize.put a | none => pure () match ctors with | some c => putCtors c | none => pure () | .recr k isUnsafe lvls params indices motives minors typ rules => do @@ -283,16 +278,13 @@ def get : GetM RevealMutConstInfo := do let value ← getOpt mask 16 Serialize.get return .defn kind safety lvls typ value | 1 => do -- Indc - let isRecr ← getOpt mask 1 getBoolField - let refl ← getOpt mask 2 getBoolField - let isUnsafe ← getOpt mask 4 getBoolField - let lvls ← getOpt mask 8 getTag0Size - let params ← getOpt mask 16 getTag0Size - let indices ← getOpt mask 32 getTag0Size - let nested ← getOpt mask 64 getTag0Size - let typ ← getOpt mask 128 Serialize.get - let ctors ← getOpt mask 256 getCtors - return .indc isRecr refl isUnsafe lvls params indices nested typ ctors + let isUnsafe ← getOpt mask 1 getBoolField + let lvls ← getOpt mask 2 getTag0Size + let params ← getOpt mask 4 getTag0Size + let indices ← getOpt mask 8 getTag0Size + let typ ← getOpt mask 16 Serialize.get + let ctors ← getOpt mask 32 getCtors + return .indc isUnsafe lvls params indices typ ctors | 2 => do -- Recr let k ← getOpt mask 1 getBoolField let isUnsafe ← getOpt mask 2 getBoolField diff --git a/Ix/Commit.lean b/Ix/Commit.lean index 60efed22..bd9d3dee 100644 --- a/Ix/Commit.lean +++ b/Ix/Commit.lean @@ -208,8 +208,7 @@ def openMutConst (mc : Ixon.MutConst) : RevealMutConstInfo := for j in [:i.ctors.size] do arr := arr.push (j.toUInt64, openConstructor i.ctors[j]!) return arr - .indc (some i.recr) (some i.refl) (some i.isUnsafe) - (some i.lvls) (some i.params) (some i.indices) (some i.nested) + .indc (some i.isUnsafe) (some i.lvls) (some i.params) (some i.indices) (some (exprAddr i.typ)) (some ctors) | .recr r => let rules := Id.run do diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean index 75ac5c87..b803d139 100644 --- a/Ix/CompileM.lean +++ b/Ix/CompileM.lean @@ -1112,13 +1112,10 @@ def compileInductive (i : InductiveVal) (ctorVals : Array ConstructorVal) let ctxAddrs ← getMutCtxAddrs let ind : Ixon.Inductive := { - recr := i.isRec - refl := i.isReflexive isUnsafe := i.isUnsafe lvls := i.cnst.levelParams.size.toUInt64 params := i.numParams.toUInt64 indices := i.numIndices.toUInt64 - nested := i.numNested.toUInt64 typ := typeExpr ctors := ctors } @@ -1194,13 +1191,10 @@ def compileInductiveData (i : Ind) let ctxAddrs ← getMutCtxAddrs let ind : Ixon.Inductive := { - recr := i.isRec - refl := i.isReflexive isUnsafe := i.isUnsafe lvls := i.levelParams.size.toUInt64 params := i.numParams.toUInt64 indices := i.numIndices.toUInt64 - nested := i.numNested.toUInt64 typ := typeExpr ctors := ctors } diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean index cc30fb57..81ba6c13 100644 --- a/Ix/DecompileM.lean +++ b/Ix/DecompileM.lean @@ -670,8 +670,9 @@ def decompileInductive (ind : Ixon.Inductive) (cnst : Constant) (cMeta : Constan cnst := { name, levelParams := univParams, type := typeExpr }, numParams := ind.params.toNat, numIndices := ind.indices.toNat, all := allNames, ctors := ctorNames, - numNested := ind.nested.toNat, isRec := ind.recr, - isUnsafe := ind.isUnsafe, isReflexive := ind.refl } + -- temporary stub until we update the Lean compiler and decompiler semantics + numNested := 0, isRec := false + isUnsafe := ind.isUnsafe, isReflexive := false } pure (indVal, ctors) /-! ## Projection Handling -/ diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean index 09c96080..0bf494ac 100644 --- a/Ix/Ixon.lean +++ b/Ix/Ixon.lean @@ -341,13 +341,10 @@ structure Constructor where deriving BEq, Repr, Inhabited structure Inductive where - recr : Bool - refl : Bool isUnsafe : Bool lvls : UInt64 params : UInt64 indices : UInt64 - nested : UInt64 typ : Expr ctors : Array Constructor deriving BEq, Repr, Inhabited @@ -873,30 +870,26 @@ instance : Serialize Constructor where get := getConstructor def putInductive (i : Inductive) : PutM Unit := do - putU8 (packBools [i.recr, i.refl, i.isUnsafe]) + putU8 (packBools [i.isUnsafe]) putTag0 ⟨i.lvls⟩ putTag0 ⟨i.params⟩ putTag0 ⟨i.indices⟩ - putTag0 ⟨i.nested⟩ putExpr i.typ putTag0 ⟨i.ctors.size.toUInt64⟩ for c in i.ctors do putConstructor c def getInductive : GetM Inductive := do - let bools := unpackBools 3 (← getU8) - let recr := bools[0]! - let refl := bools[1]! - let isUnsafe := bools[2]! + let bools := unpackBools 1 (← getU8) + let isUnsafe := bools[0]! let lvls := (← getTag0).size let params := (← getTag0).size let indices := (← getTag0).size - let nested := (← getTag0).size let typ ← getExpr let numCtors := (← getTag0).size.toNat let mut ctors := #[] for _ in [0:numCtors] do ctors := ctors.push (← getConstructor) - return ⟨recr, refl, isUnsafe, lvls, params, indices, nested, typ, ctors⟩ + return ⟨isUnsafe, lvls, params, indices, typ, ctors⟩ instance : Serialize Inductive where put := putInductive diff --git a/Tests/Gen/Claim.lean b/Tests/Gen/Claim.lean index da876b74..a915ee52 100644 --- a/Tests/Gen/Claim.lean +++ b/Tests/Gen/Claim.lean @@ -45,8 +45,7 @@ def genRevealMutConstInfo : Gen RevealMutConstInfo := <$> genOptional genDefKind <*> genOptional genDefinitionSafety <*> genOptional genUInt64Small <*> genOptional genAddress <*> genOptional genAddress), (5, RevealMutConstInfo.indc - <$> genOptional genBool <*> genOptional genBool <*> genOptional genBool - <*> genOptional genUInt64Small <*> genOptional genUInt64Small + <$> genOptional genBool <*> genOptional genUInt64Small <*> genOptional genUInt64Small <*> genOptional genUInt64Small <*> genOptional genAddress <*> genOptional (genSmallArray (Prod.mk <$> genUInt64Small <*> genRevealConstructorInfo))), diff --git a/Tests/Gen/Ixon.lean b/Tests/Gen/Ixon.lean index 24a7df99..4f767844 100644 --- a/Tests/Gen/Ixon.lean +++ b/Tests/Gen/Ixon.lean @@ -110,8 +110,8 @@ def genConstructor : Gen Constructor := .mk <$> genBool <*> genUInt64Small <*> genUInt64Small <*> genUInt64Small <*> genUInt64Small <*> genExpr def genInductive : Gen Inductive := - .mk <$> genBool <*> genBool <*> genBool <*> genUInt64Small <*> genUInt64Small - <*> genUInt64Small <*> genUInt64Small <*> genExpr <*> genArray genConstructor + .mk <$> genBool <*> genUInt64Small <*> genUInt64Small + <*> genUInt64Small <*> genExpr <*> genArray genConstructor def genBinderInfo : Gen Lean.BinderInfo := diff --git a/Tests/Ix/Compile/Mutual.lean b/Tests/Ix/Compile/Mutual.lean index b9d0bdd3..ae83974e 100644 --- a/Tests/Ix/Compile/Mutual.lean +++ b/Tests/Ix/Compile/Mutual.lean @@ -465,4 +465,25 @@ public inductive DClosure (α : Type) (S : MySet (MySet α)) : MySet (MySet α) end ReducibleAliasTarget +namespace AuxDedup1 + +mutual + inductive A : Type where | mk : List B → List C → A + inductive B : Type where | leaf : B + inductive C : Type where | leaf : C +end + +end AuxDedup1 + +namespace AuxDedup2 + + inductive C : Type where | leaf : C +mutual + inductive A : Type where | mk : List B → List C → A + inductive B : Type where | leaf : B +end + +end AuxDedup2 + + end Tests.Ix.Compile.Mutual diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index c5a839bd..cadb0530 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -330,8 +330,7 @@ public def claimRevealMuts (ixonEnv : Ixon.Env) : IO AiurTestCase := do | throw <| IO.userError "Muts components empty" let revealMc : Ix.RevealMutConstInfo := match firstMc with | .defn d => .defn (some d.kind) (some d.safety) none none none - | .indc i => .indc (some i.recr) (some i.refl) (some i.isUnsafe) - none none none none none none + | .indc i => .indc (some i.isUnsafe) none none none none none | .recr r => .recr (some r.k) (some r.isUnsafe) none none none none none none none let revealInfo : Ix.RevealConstantInfo := .muts #[(0, revealMc)] diff --git a/Tests/Ix/Kernel/CheckEnv.lean b/Tests/Ix/Kernel/CheckEnv.lean index 5ba95188..088288b0 100644 --- a/Tests/Ix/Kernel/CheckEnv.lean +++ b/Tests/Ix/Kernel/CheckEnv.lean @@ -16,6 +16,7 @@ import Ix.Common import Ix.Meta import Ix.KernelCheck import Tests.Ix.Kernel.Tutorial +import Tests.Ix.Compile.Mutual import Tests.Ix.Kernel.TutorialMeta import LSpec diff --git a/crates/compile/src/compile.rs b/crates/compile/src/compile.rs index 07949d77..528e915d 100644 --- a/crates/compile/src/compile.rs +++ b/crates/compile/src/compile.rs @@ -1905,13 +1905,10 @@ pub fn apply_sharing_to_mutual_block( }) .collect(); IxonMutConst::Indc(Inductive { - recr: ind.recr, - refl: ind.refl, is_unsafe: ind.is_unsafe, lvls: ind.lvls, params: ind.params, indices: ind.indices, - nested: ind.nested, typ: rewritten[indices[0]].clone(), ctors: new_ctors, }) @@ -2200,8 +2197,6 @@ pub fn compile_inductive( univ_params.iter().map(|n| compile_name(n, stt)).collect(); let data = Inductive { - recr: ind.ind.is_rec, - refl: ind.ind.is_reflexive, is_unsafe: ind.ind.is_unsafe, lvls: univ_params.len() as u64, params: nat_to_u64(&ind.ind.num_params, "inductive num_params too large")?, @@ -2209,7 +2204,6 @@ pub fn compile_inductive( &ind.ind.num_indices, "inductive num_indices too large", )?, - nested: nat_to_u64(&ind.ind.num_nested, "num_nested too large")?, typ, ctors, }; @@ -5025,13 +5019,10 @@ mod tests { ); let ind = Inductive { - recr: false, - refl: false, is_unsafe: false, lvls: 0, params: 0, indices: 0, - nested: 0, typ: rewritten[0].clone(), ctors: ctors .into_iter() diff --git a/crates/compile/src/compile/aux_gen.rs b/crates/compile/src/compile/aux_gen.rs index f9e06e5a..b6dec909 100644 --- a/crates/compile/src/compile/aux_gen.rs +++ b/crates/compile/src/compile/aux_gen.rs @@ -1021,13 +1021,10 @@ pub fn populate_canon_kenv_with_below( lvls: i.level_params.len() as u64, params: i.n_params as u64, indices: i.n_indices as u64, - is_rec: false, - is_refl: false, is_unsafe: false, ctors: ctor_zids, ty: ty_z, block: zid, - nested: 0, member_idx: 0, lean_all: vec![], }, diff --git a/crates/compile/src/compile/aux_gen/expr_utils.rs b/crates/compile/src/compile/aux_gen/expr_utils.rs index 92105974..7bfdc26a 100644 --- a/crates/compile/src/compile/aux_gen/expr_utils.rs +++ b/crates/compile/src/compile/aux_gen/expr_utils.rs @@ -1781,13 +1781,10 @@ pub fn ensure_prelude_in_kenv_of( lvls: 1, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, ctors: vec![unit_id], ty: punit_ty, block: punit_id, - nested: 0, member_idx: 0, lean_all: vec![], }, @@ -1890,13 +1887,10 @@ pub fn ensure_prelude_in_kenv_of( lvls: 2, params: 2, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, ctors: vec![mk_id], ty: pprod_ty, block: pprod_id, - nested: 0, member_idx: 0, lean_all: vec![], }, @@ -2030,13 +2024,10 @@ fn ensure_in_kenv_of_inner_env( lvls: n_lvls, params: nat_to_u64(&ind.num_params), indices: nat_to_u64(&ind.num_indices), - is_rec: ind.is_rec, - is_refl: ind.is_reflexive, is_unsafe: ind.is_unsafe, ctors: ctor_zids, ty: ty_z, block: zid, - nested: nat_to_u64(&ind.num_nested), member_idx: 0, lean_all: vec![], }, diff --git a/crates/compile/src/compile/aux_gen/nested.rs b/crates/compile/src/compile/aux_gen/nested.rs index 5a57d2c2..b7841a09 100644 --- a/crates/compile/src/compile/aux_gen/nested.rs +++ b/crates/compile/src/compile/aux_gen/nested.rs @@ -16,6 +16,7 @@ use bignat::Nat; use blake3::Hash; +use rayon::iter::{IntoParallelRefIterator, ParallelIterator}; use rustc_hash::{FxHashMap, FxHashSet}; use super::expr_utils::{ @@ -2065,17 +2066,131 @@ fn try_detect_nested_fvar( }); } -// NOTE: the kernel-level `compute_occurrence_levels` / `compute_expr_sort_level` -// / `extract_level_param_with_offset` / `peel_succ` helpers, and their -// transitive dep `super::below::get_ind_sort_level`, were removed as part -// of Round 2 dead-code cleanup. They implemented the principled universe -// recomputation per `elim_nested_inductive_fn` in the C++ kernel, but -// were never wired into the live pipeline — `try_detect_nested_fvar` uses -// raw `head_levels` and `maximize_occurrence_levels` does pointwise-max -// per external name. If we ever need the principled path (e.g., for -// heterogeneous nested args like `HashMap (List α) (Array β)`), revive -// from git history; the current live pipeline has zero observed failures -// on 25k+ constants via `validate-aux`. +/// Lean-faithful declaration flags for an original mutual block +pub struct LeanIndFlags { + pub is_rec: bool, + pub is_reflexive: bool, + pub num_nested: u64, +} + +/// Recompute Lean's block-wide `isRec` / `isReflexive` / `numNested` for the +/// original mutual group `all` +/// used whereever an `InductiveVal` must be reconstructed without a Lean env +/// to copy from, such as kernel egress and decompile, since Ixon doesn't store +/// these flags +pub fn compute_lean_ind_flags( + all: &[Name], + lean_env: &LeanEnv, +) -> Result { + let expanded = expand_nested_block(all, lean_env, &FxHashMap::default())?; + let num_nested = (expanded.types.len() - expanded.n_originals) as u64; + let block_names: FxHashSet<&Name> = + expanded.types.iter().map(|m| &m.name).collect(); + + let mut occ_cache: FxHashMap = FxHashMap::default(); + let mut is_rec = false; + let mut is_reflexive = false; + for member in &expanded.types { + for ctor in &member.ctors { + let mut ty = &ctor.typ; + while let ExprData::ForallE(_, dom, body, _, _) = ty.as_data() { + if has_ind_occ(dom, &block_names, &mut occ_cache) { + is_rec = true; + if matches!(dom.as_data(), ExprData::ForallE(..)) { + is_reflexive = true; + } + } + ty = body; + } + } + } + Ok(LeanIndFlags { is_rec, is_reflexive, num_nested }) +} + +/// Validate that every inductive group in `lean_env` carries exactly the flags +/// `compute_lean_ind_flags` recomputes. +pub fn validate_lean_ind_flags(lean_env: &LeanEnv) -> Result<(), CompileError> { + let mut groups: FxHashMap<&Name, &[Name]> = FxHashMap::default(); + for ci in lean_env.values() { + if let ConstantInfo::InductInfo(v) = ci + && let Some(first) = v.all.first() + { + groups.entry(first).or_insert(v.all.as_slice()); + } + } + //let groups: Vec<(&Name, &[Name])> = groups.into_iter().collect(); + groups.par_iter().try_for_each(|(_, all)| { + for member in all.iter() { + let Some(ConstantInfo::InductInfo(v)) = lean_env.get(member) else { + return Ok(()); + }; + for cn in &v.ctors { + if !matches!(lean_env.get(cn), Some(ConstantInfo::CtorInfo(_))) { + return Ok(()); + } + } + } + let flags = compute_lean_ind_flags(all, lean_env)?; + for member in all.iter() { + let Some(ConstantInfo::InductInfo(v)) = lean_env.get(member) else { + continue; // unreachable + }; + if v.is_rec != flags.is_rec + || v.is_reflexive != flags.is_reflexive + || v.num_nested != Nat::from(flags.num_nested) + { + return Err(CompileError::InvalidMutualBlock { + reason: format!( + "non-canonical inductive flags for '{}': \ + stored isRec={}isReflexive={} numNested={}, \ + computed isRec={}isReflexive={} numNested={}", + member.pretty(), + v.is_rec, + v.is_reflexive, + v.num_nested, + flags.is_rec, + flags.is_reflexive, + flags.num_nested, + ), + }); + } + } + Ok(()) + }) +} + +// does `expr` mention any block type by name anywhere? +// hash-memoized like `has_out_of_scc_const` - ctor types share subterm DAGS +fn has_ind_occ( + expr: &LeanExpr, + names: &FxHashSet<&Name>, + cache: &mut FxHashMap, +) -> bool { + let key = *expr.get_hash(); + if let Some(&cached) = cache.get(&key) { + return cached; + } + let result = match expr.as_data() { + ExprData::Const(name, _, _) => names.contains(name), + ExprData::App(f, a, _) => { + has_ind_occ(f, names, cache) || has_ind_occ(a, names, cache) + }, + ExprData::Lam(_, t, b, _, _) | ExprData::ForallE(_, t, b, _, _) => { + has_ind_occ(t, names, cache) || has_ind_occ(b, names, cache) + }, + ExprData::LetE(_, t, v, b, _, _) => { + has_ind_occ(t, names, cache) + || has_ind_occ(v, names, cache) + || has_ind_occ(b, names, cache) + }, + ExprData::Proj(_, _, e, _) | ExprData::Mdata(_, e, _) => { + has_ind_occ(e, names, cache) + }, + _ => false, + }; + cache.insert(key, result); + result +} #[cfg(test)] mod tests { @@ -2338,4 +2453,80 @@ mod tests { let r = build_compile_flat_block(&[mk_name_for("Pretender")], &env); assert!(r.is_err()); } + + /// Recursive single-ctor inductive `N` with a real `CtorInfo` entry + /// (`minimal_nat_env`'s axiom-shaped ctors are invisible to + /// `expand_nested_block`'s ctor seeding). Canonical flags: + /// isRec=true, isReflexive=false, numNested=0. + fn flags_env(is_rec: bool, is_reflexive: bool, num_nested: u64) -> LeanEnv { + use ix_common::env::ConstructorVal; + let mut env = LeanEnv::default(); + let n = mk_name_for("N"); + env.insert( + n.clone(), + ConstantInfo::InductInfo(InductiveVal { + cnst: ConstantVal { + name: n.clone(), + level_params: vec![], + typ: LeanExpr::sort(LL::succ(LL::zero())), + }, + num_params: Nat::from(0u64), + num_indices: Nat::from(0u64), + all: vec![n.clone()], + ctors: vec![mk_name_for("N.mk")], + num_nested: Nat::from(num_nested), + is_rec, + is_unsafe: false, + is_reflexive, + }), + ); + // N.mk : N → N + env.insert( + mk_name_for("N.mk"), + ConstantInfo::CtorInfo(ConstructorVal { + cnst: ConstantVal { + name: mk_name_for("N.mk"), + level_params: vec![], + typ: LeanExpr::all( + mk_name_for("_"), + LeanExpr::cnst(n.clone(), vec![]), + LeanExpr::cnst(n.clone(), vec![]), + ix_common::env::BinderInfo::Default, + ), + }, + induct: n, + cidx: Nat::from(0u64), + num_params: Nat::from(0u64), + num_fields: Nat::from(1u64), + is_unsafe: false, + }), + ); + env + } + + #[test] + fn validate_lean_ind_flags_accepts_canonical() { + assert!(validate_lean_ind_flags(&flags_env(true, false, 0)).is_ok()); + } + + #[test] + fn validate_lean_ind_flags_rejects_bad_is_rec() { + let r = validate_lean_ind_flags(&flags_env(false, false, 0)); + assert!(matches!(r, Err(CompileError::InvalidMutualBlock { .. }))); + } + + #[test] + fn validate_lean_ind_flags_rejects_bad_num_nested() { + let r = validate_lean_ind_flags(&flags_env(true, false, 1)); + assert!(matches!(r, Err(CompileError::InvalidMutualBlock { .. }))); + } + + #[test] + fn validate_lean_ind_flags_skips_unresolvable_group() { + // Wrong flags, but the ctor entry is removed → group unresolvable → + // skipped (grounding owns partial envs), not rejected. + let mut env = flags_env(false, false, 0); + env.remove(&mk_name_for("N.mk")); + assert!(validate_lean_ind_flags(&env).is_ok()); + } } diff --git a/crates/compile/src/compile/aux_gen/recursor.rs b/crates/compile/src/compile/aux_gen/recursor.rs index 6c8924b6..1eb607c9 100644 --- a/crates/compile/src/compile/aux_gen/recursor.rs +++ b/crates/compile/src/compile/aux_gen/recursor.rs @@ -2350,7 +2350,6 @@ fn compute_is_large_and_k( u64, Vec>, ix_kernel::expr::KExpr, - bool, )> = Vec::new(); // Use the first class's block KId as the shared block reference. @@ -2418,10 +2417,7 @@ fn compute_is_large_and_k( lvls: cls_n_lvls, params: n_params as u64, indices: cls_n_indices, - is_rec: cls_ind.is_rec, - is_refl: cls_ind.is_reflexive, is_unsafe: cls_ind.is_unsafe, - nested: 0, block: block_zid.clone(), member_idx: ci as u64, ty: cls_ty_z.clone(), @@ -2448,7 +2444,6 @@ fn compute_is_large_and_k( cls_n_indices, cls_ctor_zids, cls_ty_z, - false, // is_rec — not needed for is_large check )); } diff --git a/crates/compile/src/compile/env.rs b/crates/compile/src/compile/env.rs index 0b36bc23..4b92f745 100644 --- a/crates/compile/src/compile/env.rs +++ b/crates/compile/src/compile/env.rs @@ -15,7 +15,9 @@ use rayon::prelude::*; use rustc_hash::FxHashSet; use crate::compile::{ - BlockCache, CompileOptions, CompileState, compile_const, compile_const_no_aux, + BlockCache, CompileOptions, CompileState, + aux_gen::nested::validate_lean_ind_flags, compile_const, + compile_const_no_aux, }; use crate::condense::compute_sccs; use crate::graph::{NameSet, build_ref_graph}; @@ -177,6 +179,16 @@ pub fn compile_env_with_options( ); } + // Domain restriction: reject environments with non-canonical inductive flags + let phase_start = Instant::now(); + validate_lean_ind_flags(lean_env.as_ref())?; + if !*IX_QUIET { + eprintln!( + "[compile_env] setup 4/7 validate_ind_flags: {:.2}s", + phase_start.elapsed().as_secs_f32() + ); + } + let stt = CompileState { lean_env: Some(lean_env.clone()), ungrounded: ungrounded_map, diff --git a/crates/compile/src/decompile.rs b/crates/compile/src/decompile.rs index 6f5edcc3..e0165c54 100644 --- a/crates/compile/src/decompile.rs +++ b/crates/compile/src/decompile.rs @@ -39,6 +39,7 @@ use ixon::{ use crate::{ compile::CompileState, + compile::aux_gen::nested::compute_lean_ind_flags, mutual::{Def, Ind, MutConst as LeanMutConst, MutCtx, all_to_ctx}, }; use dashmap::DashMap; @@ -1622,9 +1623,9 @@ fn decompile_inductive( num_indices: Nat::from(ind.indices), all, ctors: ctor_names, - num_nested: Nat::from(ind.nested), - is_rec: ind.recr, - is_reflexive: ind.refl, + num_nested: Nat::from(0u64), + is_rec: false, + is_reflexive: false, is_unsafe: ind.is_unsafe, }; @@ -2718,8 +2719,19 @@ fn roundtrip_block( .map(|ci| vec![(name.clone(), ci)]) }, (Some(MutConst::Indc(ind)), LeanMutConst::Indc(_)) => { - let (iv, cvs) = + let (mut iv, cvs) = decompile_inductive(ind, &orig_meta, &mut dec_cache, stt, dstt)?; + // Recompute the lean flags, which are not stored by Ixon + let flags = compute_lean_ind_flags(&iv.all, generated_consts) + .map_err(|e| DecompileError::BadConstantFormat { + msg: format!( + "roundtrip ind-flags for '{}': {e}", + name.pretty() + ), + })?; + iv.num_nested = Nat::from(flags.num_nested); + iv.is_rec = flags.is_rec; + iv.is_reflexive = flags.is_reflexive; let mut entries = vec![(name.clone(), LeanConstantInfo::InductInfo(iv))]; for cv in cvs { @@ -4299,6 +4311,40 @@ pub fn decompile_env( dstt.env.len(), ); + // Pass 1.5: Lean-faithful inductive flags + let t_p1_5 = std::time::Instant::now(); + let lean_env: ix_common::env::Env = + dstt.env.iter().map(|e| (e.key().clone(), e.value().clone())).collect(); + let mut groups: FxHashMap> = FxHashMap::default(); + for entry in dstt.env.iter() { + if let LeanConstantInfo::InductInfo(v) = entry.value() { + if let Some(first) = v.all.first() { + groups.entry(first.clone()).or_insert_with(|| v.all.clone()); + } + } + } + for (key, all) in &groups { + let flags = compute_lean_ind_flags(all, &lean_env).map_err(|e| { + DecompileError::BadConstantFormat { + msg: format!("ind-flags fixup for block '{}': {e}", key.pretty()), + } + })?; + for member in all { + if let Some(mut entry) = dstt.env.get_mut(member) { + if let LeanConstantInfo::InductInfo(v) = entry.value_mut() { + v.num_nested = Nat::from(flags.num_nested); + v.is_rec = flags.is_rec; + v.is_reflexive = flags.is_reflexive; + } + } + } + } + eprintln!( + "[decompile] Pass 1.5 done in {:.2}s ({} constants in dstt.env)", + t_p1_5.elapsed().as_secs_f32(), + groups.len(), + ); + // Pass 2: Regenerate aux_gen constants for mutual inductive blocks. // Process blocks in topological order so that when block B's constructor // fields reference inductives from block A, A's generated auxiliaries diff --git a/crates/compile/src/kernel_egress.rs b/crates/compile/src/kernel_egress.rs index 743f97db..becbb8db 100644 --- a/crates/compile/src/kernel_egress.rs +++ b/crates/compile/src/kernel_egress.rs @@ -1,4 +1,4 @@ -//! Egress: convert zero kernel types (`Meta` mode) to `src/ix/env.rs` Lean types. +//! Egress: convert kernel types (`Meta` mode) to `src/ix/env.rs` Lean types. //! //! Only works for `Meta` mode since it needs actual names and binder info. @@ -15,6 +15,8 @@ use ix_common::env::{ }; use ixon::constant::DefKind; +use crate::compile::aux_gen::nested::compute_lean_ind_flags; +use dashmap::DashMap; use ix_kernel::constant::KConst; use ix_kernel::env::KEnv; use ix_kernel::expr::{ExprData, KExpr, MData}; @@ -22,7 +24,7 @@ use ix_kernel::id::KId; use ix_kernel::level::{KUniv, UnivData}; use ix_kernel::mode::Meta; -/// Convert a zero kernel universe to a Lean level. +/// Convert a kernel universe to a Lean level. fn egress_level(u: &KUniv, level_params: &[Name]) -> env::Level { match u.data() { UnivData::Zero(_) => env::Level::zero(), @@ -55,7 +57,7 @@ fn egress_levels( /// Expression egress cache, keyed by content hash. type Cache = FxHashMap; -/// Convert a zero kernel expression to a Lean expression. +/// Convert a kernel expression to a Lean expression. fn egress_expr( expr: &KExpr, level_params: &[Name], @@ -127,7 +129,7 @@ fn zids_to_names(ids: &[KId]) -> Vec { ids.iter().map(|id| id.name.clone()).collect() } -/// Convert a zero kernel constant to a Lean `ConstantInfo`. +/// Convert a kernel constant to a Lean `ConstantInfo`. pub fn egress_constant(zc: &KConst) -> LeanCI { let mut cache = Cache::default(); @@ -198,10 +200,7 @@ pub fn egress_constant(zc: &KConst) -> LeanCI { level_params, params, indices, - is_rec, - is_refl, is_unsafe, - nested, ty, ctors, lean_all, @@ -218,10 +217,11 @@ pub fn egress_constant(zc: &KConst) -> LeanCI { num_indices: Nat::from(*indices), all: zids_to_names(lean_all), ctors: zids_to_names(ctors), - num_nested: Nat::from(*nested), - is_rec: *is_rec, is_unsafe: *is_unsafe, - is_reflexive: *is_refl, + // temporary stubs that get recomputed in lean_egress stage 2 + num_nested: Nat::from(0u64), + is_rec: false, + is_reflexive: false, }) }, @@ -295,20 +295,40 @@ pub fn egress_constant(zc: &KConst) -> LeanCI { } } -/// Convert the entire zero kernel environment to a Lean environment. -pub fn lean_egress(zenv: &KEnv) -> env::Env { +/// Convert the entire kernel environment to a Lean environment. +pub fn lean_egress(zenv: &KEnv) -> Result { let entries: Vec<_> = zenv.iter().collect(); - let results: Vec<(Name, LeanCI)> = entries - .into_par_iter() - .map(|(id, zc)| (id.name.clone(), egress_constant(&zc))) - .collect(); - - let mut lean_env = env::Env::default(); - for (name, ci) in results { - lean_env.insert(name, ci); + // Stage 1: egresss everything in parallel, split inductives into a staging + // area + let egressed: DashMap = DashMap::with_capacity(entries.len()); + let groups: DashMap> = DashMap::new(); + entries.into_par_iter().for_each(|(id, zc)| { + let ci = egress_constant(&zc); + if let LeanCI::InductInfo(v) = &ci { + if let Some(first) = v.all.first() { + groups.entry(first.clone()).or_insert_with(|| v.all.clone()); + } + } + egressed.insert(id.name.clone(), ci); + }); + + // Stage 2: fixup the staged inductive flags which were stubbed + let mut lean_env: env::Env = egressed.into_iter().collect(); + for entry in groups.iter() { + let (key, all) = (entry.key(), entry.value()); + let f = compute_lean_ind_flags(all, &lean_env).map_err(|e| { + format!("lean_egress: ind flags for '{}': {e}", key.pretty()) + })?; + for member in all { + if let Some(LeanCI::InductInfo(v)) = lean_env.get_mut(member) { + v.is_rec = f.is_rec; + v.is_rec = f.is_reflexive; + v.num_nested = Nat::from(f.num_nested); + } + } } - lean_env + Ok(lean_env) } // =========================================================================== @@ -653,18 +673,7 @@ fn kind_to_ixon( ctor_kconsts: &[&KConst], ctx: &mut EgressCtx, ) -> Result { - let KConst::Indc { - lvls, - params, - indices, - is_rec, - is_refl, - is_unsafe, - nested, - ty, - .. - } = ind_kc - else { + let KConst::Indc { lvls, params, indices, is_unsafe, ty, .. } = ind_kc else { return Err(format!( "kind_to_ixon: expected Indc, got {}", kc_kind(ind_kc) @@ -694,13 +703,10 @@ fn kind_to_ixon( .collect::>()?; Ok(IxonInductive { - recr: *is_rec, - refl: *is_refl, is_unsafe: *is_unsafe, lvls: *lvls, params: *params, indices: *indices, - nested: *nested, typ, ctors, }) @@ -1573,10 +1579,7 @@ mod tests { lvls: 0, params: 2, indices: 3, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 1, block: mk_id("A"), member_idx: 0, ty: sort0(), @@ -1588,8 +1591,8 @@ mod tests { LeanCI::InductInfo(v) => { assert_eq!(v.num_params.to_u64(), Some(2)); assert_eq!(v.num_indices.to_u64(), Some(3)); - assert_eq!(v.num_nested.to_u64(), Some(1)); - assert!(v.is_rec); + assert_eq!(v.num_nested.to_u64(), Some(0)); + assert!(!v.is_rec); assert!(!v.is_reflexive); assert_eq!(v.all.len(), 1); assert_eq!(v.ctors.len(), 1); @@ -1663,7 +1666,7 @@ mod tests { #[test] fn lean_egress_on_empty_env() { let zenv = KEnv::::new(); - let le = lean_egress(&zenv); + let le = lean_egress(&zenv).unwrap(); // `Env` is a `FxHashMap`. assert_eq!(le.len(), 0); } @@ -1684,7 +1687,7 @@ mod tests { }, ); } - let le = lean_egress(&zenv); + let le = lean_egress(&zenv).unwrap(); assert_eq!(le.len(), 3); for name in ["A", "B", "C"] { let ci = le.get(&mk_name(name)).expect("missing name"); diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index a386d6a2..c645bf18 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -3444,7 +3444,14 @@ pub extern "C" fn rs_kernel_roundtrip_no_compile( // Egress kernel → Lean. let t2 = Instant::now(); - let egressed_env = lean_egress(&kenv); + let egressed_env = match lean_egress(&kenv) { + Ok(env) => env, + Err(e) => { + return LeanIOResult::error_string(&format!( + "rs_kernel_roundtrip_no_compile: egress failed {e}" + )); + }, + }; eprintln!( "[rs_kernel_roundtrip_no_compile] egress: {:>8.1?} ({} consts)", t2.elapsed(), diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs index 221a8530..0fc8d29e 100644 --- a/crates/ffi/src/lean.rs +++ b/crates/ffi/src/lean.rs @@ -39,7 +39,7 @@ lean_ffi::lean_inductive! { LeanIxonAxiom [ { num_obj: 1, num_64: 1, num_8: 1 } ]; LeanIxonQuotient [ { num_obj: 1, num_64: 1, num_8: 1 } ]; LeanIxonConstructor [ { num_obj: 1, num_64: 4, num_8: 1 } ]; - LeanIxonInductive [ { num_obj: 2, num_64: 4, num_8: 3 } ]; + LeanIxonInductive [ { num_obj: 2, num_64: 3, num_8: 1 } ]; LeanIxonInductiveProj [ { num_obj: 1, num_64: 1 } ]; LeanIxonConstructorProj [ { num_obj: 1, num_64: 2 } ]; LeanIxonRecursorProj [ { num_obj: 1, num_64: 1 } ]; diff --git a/crates/ffi/src/lean_ixon/constant.rs b/crates/ffi/src/lean_ixon/constant.rs index d5fe112f..898736c7 100644 --- a/crates/ffi/src/lean_ixon/constant.rs +++ b/crates/ffi/src/lean_ixon/constant.rs @@ -294,17 +294,14 @@ impl LeanIxonInductive { ctor.set_num_64(0, ind.lvls); ctor.set_num_64(1, ind.params); ctor.set_num_64(2, ind.indices); - ctor.set_num_64(3, ind.nested); - ctor.set_num_8(0, u8::from(ind.recr)); - ctor.set_num_8(1, u8::from(ind.refl)); - ctor.set_num_8(2, u8::from(ind.is_unsafe)); + ctor.set_num_8(0, u8::from(ind.is_unsafe)); ctor } } impl LeanIxonInductive { /// Decode Ixon.Inductive. - /// Scalars ordered by size: lvls(8) + params(8) + indices(8) + nested(8) + recr(1) + refl(1) + isUnsafe(1) + padding(5) + /// Scalars ordered by size: lvls(8) + params(8) + indices(8) + isUnsafe(1) + padding(5) pub fn decode(&self) -> IxonInductive { let ctor = self.as_ctor(); let typ = Arc::new(LeanIxonExpr::new(ctor.get(0).to_owned_ref()).decode()); @@ -314,21 +311,8 @@ impl LeanIxonInductive { let lvls = self.get_num_64(0); let params = self.get_num_64(1); let indices = self.get_num_64(2); - let nested = self.get_num_64(3); - let recr = self.get_num_8(0) != 0; - let refl = self.get_num_8(1) != 0; - let is_unsafe = self.get_num_8(2) != 0; - IxonInductive { - recr, - refl, - is_unsafe, - lvls, - params, - indices, - nested, - typ, - ctors, - } + let is_unsafe = self.get_num_8(0) != 0; + IxonInductive { is_unsafe, lvls, params, indices, typ, ctors } } } diff --git a/crates/ixon/src/constant.rs b/crates/ixon/src/constant.rs index 12cc881b..da6411ec 100644 --- a/crates/ixon/src/constant.rs +++ b/crates/ixon/src/constant.rs @@ -107,10 +107,6 @@ pub struct Constructor { /// An inductive type. #[derive(Clone, Debug, PartialEq, Eq)] pub struct Inductive { - /// Has recursive occurrences - pub recr: bool, - /// Is reflexive - pub refl: bool, pub is_unsafe: bool, /// Number of universe parameters pub lvls: u64, @@ -118,8 +114,6 @@ pub struct Inductive { pub params: u64, /// Number of indices pub indices: u64, - /// Nested inductive depth - pub nested: u64, /// Type expression pub typ: Arc, /// Constructors @@ -396,13 +390,10 @@ pub mod tests { pub fn gen_inductive(g: &mut Gen) -> Inductive { Inductive { - recr: bool::arbitrary(g), - refl: bool::arbitrary(g), is_unsafe: bool::arbitrary(g), lvls: u64::arbitrary(g) % 10, params: u64::arbitrary(g) % 10, indices: u64::arbitrary(g) % 5, - nested: u64::arbitrary(g) % 3, typ: arbitrary_expr(g), ctors: (0..gen_range(g, 0..4)).map(|_| gen_constructor(g)).collect(), } diff --git a/crates/ixon/src/proof.rs b/crates/ixon/src/proof.rs index 94fc2b6e..d31742ab 100644 --- a/crates/ixon/src/proof.rs +++ b/crates/ixon/src/proof.rs @@ -50,13 +50,10 @@ pub enum RevealMutConstInfo { value: Option
, }, Indc { - recr: Option, - refl: Option, is_unsafe: Option, lvls: Option, params: Option, indices: Option, - nested: Option, typ: Option
, ctors: Option>, }, @@ -470,36 +467,17 @@ impl RevealMutConstInfo { buf.extend_from_slice(v.as_bytes()); } }, - Self::Indc { - recr, - refl, - is_unsafe, - lvls, - params, - indices, - nested, - typ, - ctors, - } => { + Self::Indc { is_unsafe, lvls, params, indices, typ, ctors } => { buf.push(1); let mask = compute_mask(&[ - recr.is_some(), - refl.is_some(), is_unsafe.is_some(), lvls.is_some(), params.is_some(), indices.is_some(), - nested.is_some(), typ.is_some(), ctors.is_some(), ]); Tag0::new(mask).put(buf); - if let Some(r) = recr { - put_bool_field(*r, buf); - } - if let Some(r) = refl { - put_bool_field(*r, buf); - } if let Some(u) = is_unsafe { put_bool_field(*u, buf); } @@ -512,9 +490,6 @@ impl RevealMutConstInfo { if let Some(i) = indices { Tag0::new(*i).put(buf); } - if let Some(n) = nested { - Tag0::new(*n).put(buf); - } if let Some(t) = typ { buf.extend_from_slice(t.as_bytes()); } @@ -592,33 +567,17 @@ impl RevealMutConstInfo { Ok(Self::Defn { kind, safety, lvls, typ, value }) }, 1 => { - let recr = - if mask & 1 != 0 { Some(get_bool_field(buf)?) } else { None }; - let refl = - if mask & 2 != 0 { Some(get_bool_field(buf)?) } else { None }; let is_unsafe = - if mask & 4 != 0 { Some(get_bool_field(buf)?) } else { None }; + if mask & 1 != 0 { Some(get_bool_field(buf)?) } else { None }; let lvls = - if mask & 8 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 2 != 0 { Some(Tag0::get(buf)?.size) } else { None }; let params = - if mask & 16 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + if mask & 4 != 0 { Some(Tag0::get(buf)?.size) } else { None }; let indices = - if mask & 32 != 0 { Some(Tag0::get(buf)?.size) } else { None }; - let nested = - if mask & 64 != 0 { Some(Tag0::get(buf)?.size) } else { None }; - let typ = if mask & 128 != 0 { Some(get_address(buf)?) } else { None }; - let ctors = if mask & 256 != 0 { Some(get_ctors(buf)?) } else { None }; - Ok(Self::Indc { - recr, - refl, - is_unsafe, - lvls, - params, - indices, - nested, - typ, - ctors, - }) + if mask & 8 != 0 { Some(Tag0::get(buf)?.size) } else { None }; + let typ = if mask & 16 != 0 { Some(get_address(buf)?) } else { None }; + let ctors = if mask & 32 != 0 { Some(get_ctors(buf)?) } else { None }; + Ok(Self::Indc { is_unsafe, lvls, params, indices, typ, ctors }) }, 2 => { let k = if mask & 1 != 0 { Some(get_bool_field(buf)?) } else { None }; @@ -1282,13 +1241,10 @@ mod tests { value: gen_opt_addr(g), }, 1 => Self::Indc { - recr: gen_opt_bool(g), - refl: gen_opt_bool(g), is_unsafe: gen_opt_bool(g), lvls: gen_opt_u64(g), params: gen_opt_u64(g), indices: gen_opt_u64(g), - nested: gen_opt_u64(g), typ: gen_opt_addr(g), ctors: gen_opt_ctors(g), }, @@ -2003,13 +1959,10 @@ mod tests { ( 0, RevealMutConstInfo::Indc { - recr: Some(true), - refl: None, is_unsafe: Some(false), lvls: None, params: Some(2), indices: None, - nested: None, typ: None, ctors: Some(vec![( 0, diff --git a/crates/ixon/src/serialize.rs b/crates/ixon/src/serialize.rs index 0acffb0f..2e2fd9b8 100644 --- a/crates/ixon/src/serialize.rs +++ b/crates/ixon/src/serialize.rs @@ -641,11 +641,10 @@ impl Constructor { impl Inductive { pub fn put(&self, buf: &mut Vec) { - put_u8(pack_bools([self.recr, self.refl, self.is_unsafe]), buf); + put_u8(pack_bools([self.is_unsafe]), buf); put_u64(self.lvls, buf); put_u64(self.params, buf); put_u64(self.indices, buf); - put_u64(self.nested, buf); put_expr(&self.typ, buf); put_u64(self.ctors.len() as u64, buf); for ctor in &self.ctors { @@ -654,28 +653,17 @@ impl Inductive { } pub fn get(buf: &mut &[u8]) -> Result { - let bools = unpack_bools(3, get_u8(buf)?); + let bools = unpack_bools(1, get_u8(buf)?); let lvls = get_u64(buf)?; let params = get_u64(buf)?; let indices = get_u64(buf)?; - let nested = get_u64(buf)?; let typ = get_expr(buf)?; let num_ctors = get_u64(buf)?; let mut ctors = Vec::with_capacity(capped_capacity(num_ctors, buf)); for _ in 0..num_ctors { ctors.push(Constructor::get(buf)?); } - Ok(Inductive { - recr: bools[0], - refl: bools[1], - is_unsafe: bools[2], - lvls, - params, - indices, - nested, - typ, - ctors, - }) + Ok(Inductive { is_unsafe: bools[0], lvls, params, indices, typ, ctors }) } } diff --git a/crates/kernel/src/canonical_check.rs b/crates/kernel/src/canonical_check.rs index 9c028fec..6fcfcad8 100644 --- a/crates/kernel/src/canonical_check.rs +++ b/crates/kernel/src/canonical_check.rs @@ -294,20 +294,18 @@ pub fn compare_krec_rule( /// Field order: /// `(is_rec, is_unsafe, lvls, params, indices, |ctors|, ty, ctors[*])`. /// -/// `is_rec` and `is_unsafe` participate so alpha-collapse can't merge +/// `is_unsafe` participates so alpha-collapse can't merge /// inductives whose derived flags differ. fn compare_kindc( x_lvls: u64, x_params: u64, x_indices: u64, - x_is_rec: bool, x_is_unsafe: bool, x_ty: &KExpr, x_ctors: &[KId], y_lvls: u64, y_params: u64, y_indices: u64, - y_is_rec: bool, y_is_unsafe: bool, y_ty: &KExpr, y_ctors: &[KId], @@ -315,8 +313,7 @@ fn compare_kindc( resolve_ctor: &dyn Fn(&KId) -> Option>, ) -> Result> { Ok( - SOrd::cmp(&x_is_rec, &y_is_rec) - .compare(SOrd::cmp(&x_is_unsafe, &y_is_unsafe)) + SOrd::cmp(&x_is_unsafe, &y_is_unsafe) .compare(SOrd::cmp(&x_lvls, &y_lvls)) .compare(SOrd::cmp(&x_params, &y_params)) .compare(SOrd::cmp(&x_indices, &y_indices)) @@ -471,7 +468,6 @@ pub fn compare_kconst( lvls: xl, params: xp, indices: xi, - is_rec: xr, is_unsafe: xu, ty: xt, ctors: xc, @@ -481,7 +477,6 @@ pub fn compare_kconst( lvls: yl, params: yp, indices: yi, - is_rec: yr, is_unsafe: yu, ty: yt, ctors: yc, @@ -491,14 +486,12 @@ pub fn compare_kconst( *xl, *xp, *xi, - *xr, *xu, xt, xc, *yl, *yp, *yi, - *yr, *yu, yt, yc, @@ -872,10 +865,7 @@ mod tests { lvls: 0, params, indices, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: KId::new(mk_addr("blk"), ()), member_idx: 0, ty, diff --git a/crates/kernel/src/check.rs b/crates/kernel/src/check.rs index 094ecf5e..efa834ba 100644 --- a/crates/kernel/src/check.rs +++ b/crates/kernel/src/check.rs @@ -159,16 +159,16 @@ impl TypeChecker<'_, M> { // (delta, iota, native, ...) is missing for convergence. let val_ty_whnf = self.whnf(&val_ty); let ty_whnf = self.whnf(ty); - log::info!("[decl diff] DeclTypeMismatch"); - log::info!(" val_ty: {val_ty}"); - log::info!(" ty: {ty}"); + eprintln!("[decl diff] DeclTypeMismatch"); + eprintln!(" val_ty: {val_ty}"); + eprintln!(" ty: {ty}"); match &val_ty_whnf { - Ok(w) => log::info!(" val_ty whnf: {w}"), - Err(e) => log::info!(" val_ty whnf: ERR {e}"), + Ok(w) => eprintln!(" val_ty whnf: {w}"), + Err(e) => eprintln!(" val_ty whnf: ERR {e}"), } match &ty_whnf { - Ok(w) => log::info!(" ty whnf: {w}"), - Err(e) => log::info!(" ty whnf: ERR {e}"), + Ok(w) => eprintln!(" ty whnf: {w}"), + Err(e) => eprintln!(" ty whnf: ERR {e}"), } } return Err(TcError::DeclTypeMismatch); @@ -192,7 +192,7 @@ impl TypeChecker<'_, M> { if let Some(t0) = overall && self.phase_timing_label_matches(id) { - log::info!( + eprintln!( "[phase] {} total={:>8.1?} dup_lvls={:>8.1?} validate={:>8.1?} validate_ty={:>8.1?} validate_val={:>8.1?} validate_rules={:>8.1?} validate_univ={:>8.1?} infer_ty={:>8.1?} infer_val={:>8.1?} def_eq={:>8.1?} safety={:>8.1?} safety_ty={:>8.1?} safety_val={:>8.1?}", id, t0.elapsed(), @@ -395,7 +395,7 @@ impl TypeChecker<'_, M> { if let Some(t0) = overall && self.phase_timing_label_matches(block) { - log::info!( + eprintln!( "[phase-block] {} kind={:?} members={} total={:>8.1?} get_members={:>8.1?} prevalidate={:>8.1?} validate_ty={:>8.1?} validate_val={:>8.1?} validate_rules={:>8.1?} validate_univ={:>8.1?} classify={:>8.1?} body={:>8.1?}", block, kind, @@ -1236,10 +1236,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: true, - nested: 0, block: unsafe_ty.clone(), member_idx: 0, ty: sort1(), diff --git a/crates/kernel/src/congruence.rs b/crates/kernel/src/congruence.rs index 906ae1b2..9c8fb715 100644 --- a/crates/kernel/src/congruence.rs +++ b/crates/kernel/src/congruence.rs @@ -817,25 +817,22 @@ mod tests { num_indices: n(0), all: vec![mk_name("A")], ctors: vec![], - num_nested: n(0), is_rec: false, - is_unsafe: false, is_reflexive: false, + num_nested: bignat::Nat::from(0), + is_unsafe: false, }); let kc = KConst::::Indc { name: (), level_params: (), params: 5, // wrong indices: 0, - is_rec: false, - is_refl: false, ctors: vec![], lvls: 0, ty: KExpr::sort(KUniv::zero()), lean_all: (), block: KId::new(mk_addr("A"), ()), is_unsafe: false, - nested: 0, member_idx: 0, }; let e = const_congruent(&lci, &kc, &r).unwrap_err(); diff --git a/crates/kernel/src/constant.rs b/crates/kernel/src/constant.rs index 16a3592b..54a2d3b3 100644 --- a/crates/kernel/src/constant.rs +++ b/crates/kernel/src/constant.rs @@ -76,10 +76,7 @@ pub enum KConst { lvls: u64, params: u64, indices: u64, - is_rec: bool, - is_refl: bool, is_unsafe: bool, - nested: u64, block: KId, member_idx: u64, ty: KExpr, @@ -232,10 +229,7 @@ mod tests { lvls: 0, params: 2, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: KId::new(mk_addr("block"), ()), member_idx: 0, ty: sort0(), diff --git a/crates/kernel/src/def_eq.rs b/crates/kernel/src/def_eq.rs index e546a364..d574414e 100644 --- a/crates/kernel/src/def_eq.rs +++ b/crates/kernel/src/def_eq.rs @@ -63,7 +63,7 @@ impl TypeChecker<'_, M> { if *IX_DEF_EQ_COUNT_LOG { let n = DEF_EQ_COUNT.fetch_add(1, std::sync::atomic::Ordering::Relaxed); if n.is_multiple_of(100_000) && n > 0 { - log::info!("[is_def_eq] count={n}"); + eprintln!("[is_def_eq] count={n}"); } } crate::profile::bump_def_eq(); @@ -86,12 +86,12 @@ impl TypeChecker<'_, M> { let a_hit = head_const_name(a).is_some_and(|n| n.contains(prefix)); let b_hit = head_const_name(b).is_some_and(|n| n.contains(prefix)); if a_hit || b_hit { - log::info!( + eprintln!( "[deq] depth={} a={}", self.def_eq_depth, compact_def_eq_expr(a) ); - log::info!( + eprintln!( "[deq] depth={} b={}", self.def_eq_depth, compact_def_eq_expr(b) @@ -210,7 +210,7 @@ impl TypeChecker<'_, M> { let ok = result?; if trace_active { - log::info!( + eprintln!( "[deq] depth={} -> {} ({})", self.def_eq_depth, ok, @@ -219,8 +219,8 @@ impl TypeChecker<'_, M> { // On FAIL, also dump the full a/b that failed (post-Tier-1 quick). // Lets us see what the def-eq engine actually compared. if !ok { - log::info!("[deq fail] depth={} a-full: {a}", self.def_eq_depth); - log::info!("[deq fail] depth={} b-full: {b}", self.def_eq_depth); + eprintln!("[deq fail] depth={} a-full: {a}", self.def_eq_depth); + eprintln!("[deq fail] depth={} b-full: {b}", self.def_eq_depth); } self.def_eq_trace_depth = self.def_eq_trace_depth.saturating_sub(1); } @@ -495,9 +495,9 @@ impl TypeChecker<'_, M> { } if self.def_eq_trace_depth > 0 { - log::info!("[deq tier4 break] depth={}", self.def_eq_depth); - log::info!(" wa: {wa}"); - log::info!(" wb: {wb}"); + eprintln!("[deq tier4 break] depth={}", self.def_eq_depth); + eprintln!(" wa: {wa}"); + eprintln!(" wb: {wb}"); } // Tier 4b: post-delta congruence checks (lean4lean isDefEqConst/Fvar/Proj) @@ -544,9 +544,9 @@ impl TypeChecker<'_, M> { let a_match = head_const_name(&wa).is_some_and(|n| n.contains(&prefix)); let b_match = head_const_name(&wb).is_some_and(|n| n.contains(&prefix)); if prefix.is_empty() || a_match || b_match { - log::info!("[deq tier5 fail] depth={}", self.def_eq_depth); - log::info!(" wa: {wa}"); - log::info!(" wb: {wb}"); + eprintln!("[deq tier5 fail] depth={}", self.def_eq_depth); + eprintln!(" wa: {wa}"); + eprintln!(" wb: {wb}"); } } @@ -873,8 +873,8 @@ impl TypeChecker<'_, M> { }; // Check unit-like: non-recursive, 0 indices, 1 ctor with 0 fields let is_unit = match self.try_get_const(&a_ind)? { - Some(KConst::Indc { is_rec, indices, ctors, .. }) => { - if is_rec || indices != 0 || ctors.len() != 1 { + Some(KConst::Indc { indices, ctors, .. }) => { + if indices != 0 || ctors.len() != 1 { false } else { match self.try_get_const(&ctors[0])? { @@ -1143,29 +1143,9 @@ impl TypeChecker<'_, M> { } // Inductive must be struct-like (non-recursive, 0 indices, 1 ctor) - match self.try_get_const(&induct_id)? { - Some(KConst::Indc { is_rec, indices, ctors, .. }) => { - if is_rec || indices != 0 || ctors.len() != 1 { - self.dump_eta_trace( - "not-struct-like", - Some(&induct_id), - 0, - &t_norm, - s, - ); - return Ok(false); - } - }, - _ => { - self.dump_eta_trace( - "inductive-missing", - Some(&induct_id), - 0, - &t_norm, - s, - ); - return Ok(false); - }, + if !self.is_struct_like(&induct_id)? { + self.dump_eta_trace("not-struct-like", Some(&induct_id), 0, &t_norm, s); + return Ok(false); } // Types must be def-eq (lean4lean tryEtaStructCore, line 515). @@ -1518,7 +1498,7 @@ impl TypeChecker<'_, M> { if !filter.is_empty() && !id_s.contains(filter) { return; } - log::info!( + eprintln!( "[proj-delta] const={} depth={} phase={} proj={}.{} a={} b={}", self.debug_label.as_deref().unwrap_or(""), self.def_eq_depth, @@ -1562,7 +1542,7 @@ impl TypeChecker<'_, M> { if !filter.is_empty() && !id_s.contains(filter) { return; } - log::info!( + eprintln!( "[eta] const={} depth={} reason={} id={} idx={} a={} b={}", self.debug_label.as_deref().unwrap_or(""), self.def_eq_depth, @@ -1692,21 +1672,17 @@ impl TypeChecker<'_, M> { { return; } - log::info!( + eprintln!( "[deq max] {kind} depth={} a_head={} b_head={} wa_head={} wb_head={}", - self.def_eq_depth, - a_head, - b_head, - wa_head, - wb_head + self.def_eq_depth, a_head, b_head, wa_head, wb_head ); - log::info!(" a: {a}"); - log::info!(" b: {b}"); + eprintln!(" a: {a}"); + eprintln!(" b: {b}"); if let Some(wa) = wa { - log::info!(" wa: {wa}"); + eprintln!(" wa: {wa}"); } if let Some(wb) = wb { - log::info!(" wb: {wb}"); + eprintln!(" wb: {wb}"); } } @@ -1725,7 +1701,7 @@ impl TypeChecker<'_, M> { { return; } - log::info!( + eprintln!( "[deq max] rec-fuel depth={} a={} b={}", self.def_eq_depth, compact_def_eq_expr(a), @@ -2137,10 +2113,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: mk_id("Unit"), member_idx: 0, ty: AE::sort(AU::succ(AU::zero())), @@ -2330,10 +2303,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: mk_id("Pair"), member_idx: 0, ty: AE::sort(AU::succ(AU::zero())), diff --git a/crates/kernel/src/env.rs b/crates/kernel/src/env.rs index f93a372e..0d6e3e94 100644 --- a/crates/kernel/src/env.rs +++ b/crates/kernel/src/env.rs @@ -163,6 +163,7 @@ pub struct KEnvCacheSizes { pub unfold: usize, pub ingress: usize, pub is_prop: usize, + pub is_rec: usize, pub recursor: usize, pub rec_majors: usize, pub block_peer_agreement: usize, @@ -192,6 +193,7 @@ impl KEnvCacheSizes { self.unfold, self.ingress, self.is_prop, + self.is_rec, self.recursor, self.rec_majors, self.block_peer_agreement, @@ -331,6 +333,8 @@ pub struct KEnv { /// is the dominant cost on mathlib proof-heavy blocks, where the same /// propositions are tested for equality thousands of times. pub is_prop_cache: FxHashMap<(Addr, Addr), bool>, + /// Computed `is_rec` per inductive, keyed by content address + pub is_rec_cache: FxHashMap, /// Generated recursors, keyed by inductive Muts block id. pub recursor_cache: FxHashMap, Vec>>, /// Nested-auxiliary order expected by stored recursors in this environment. @@ -383,7 +387,7 @@ impl Drop for KEnv { if super::perf::enabled() { let summary = self.perf.summary(); if !summary.is_empty() { - log::info!("{summary}"); + eprintln!("{summary}"); } } } @@ -416,6 +420,7 @@ impl KEnv { nat_succ_stuck: FxHashSet::default(), ingress_cache: FxHashMap::default(), is_prop_cache: FxHashMap::default(), + is_rec_cache: FxHashMap::default(), recursor_cache: FxHashMap::default(), recursor_aux_order, rec_majors_cache: FxHashMap::default(), @@ -560,6 +565,7 @@ impl KEnv { unfold: self.unfold_cache.len(), ingress: self.ingress_cache.len(), is_prop: self.is_prop_cache.len(), + is_rec: self.is_rec_cache.len(), recursor: self.recursor_cache.len(), rec_majors: self.rec_majors_cache.len(), block_peer_agreement: self.block_peer_agreement_cache.len(), diff --git a/crates/kernel/src/inductive.rs b/crates/kernel/src/inductive.rs index 52e81028..182171b4 100644 --- a/crates/kernel/src/inductive.rs +++ b/crates/kernel/src/inductive.rs @@ -149,36 +149,31 @@ impl TypeChecker<'_, M> { &mut self, id: &KId, ) -> Result<(), TcError> { - let (params, indices, lvls, ctors, block, is_rec, is_unsafe, _nested, ty) = - match self.get_const(id)? { - KConst::Indc { - params, - indices, - lvls, - ctors, - block, - is_rec, - is_unsafe, - nested, - ty, - .. - } => ( - params, - indices, - lvls, - ctors.clone(), - block.clone(), - is_rec, - is_unsafe, - nested, - ty.clone(), - ), - _ => { - return Err(TcError::Other( - "check_inductive: not an inductive".into(), - )); - }, - }; + let (params, indices, lvls, ctors, block, is_unsafe, ty) = match self + .get_const(id)? + { + KConst::Indc { + params, + indices, + lvls, + ctors, + block, + is_unsafe, + ty, + .. + } => ( + params, + indices, + lvls, + ctors.clone(), + block.clone(), + is_unsafe, + ty.clone(), + ), + _ => { + return Err(TcError::Other("check_inductive: not an inductive".into())); + }, + }; // Discover all inductives in the mutual block let block_inds = self.discover_block_inductives(&block)?; @@ -304,17 +299,6 @@ impl TypeChecker<'_, M> { )?; } - // H1: Verify is_rec constructively — scan constructor fields for block references. - // An adversary could set is_rec=false on a recursive inductive to enable improper - // struct eta expansion. We verify against the actual constructor structure. - let computed_is_rec = - self.compute_is_rec(&ctors, u64_to_usize(params)?, &block_addrs)?; - if computed_is_rec != is_rec { - return Err(TcError::Other(format!( - "check_inductive: is_rec mismatch: declared {is_rec}, computed {computed_is_rec}" - ))); - } - // Trigger recursor generation for the block (fatal — ZK context cannot tolerate silent failure) if !self.env.recursor_cache.contains_key(&block) { self.generate_block_recursors(&block)?; @@ -440,6 +424,39 @@ impl TypeChecker<'_, M> { Ok(inds) } + pub fn computed_is_rec(&mut self, ind: &KId) -> Result> { + if let Some(&v) = self.env.is_rec_cache.get(&ind.addr) { + return Ok(v); + } + let (params, ctors, block) = match self.get_const(ind)? { + KConst::Indc { params, ctors, block, .. } => { + (params, ctors.clone(), block.clone()) + }, + _ => { + return Err(TcError::Other("computed_is_rec: not an inductive".into())); + }, + }; + // provisional true entry. compute_is_rec can hit the is_rec_cache via + // whnf ~> try_struct_eta_iota ~> is_struct_like ~> cache + // if and only if the inductive is recursive, so not observable otherwise + self.env.is_rec_cache.insert(ind.addr.clone(), true); + let block_inds = self.discover_block_inductives(&block)?; + let block_addrs: Vec
= + block_inds.iter().map(|id| id.addr.clone()).collect(); + match self.compute_is_rec(&ctors, u64_to_usize::(params)?, &block_addrs) + { + Ok(v) => { + self.env.is_rec_cache.insert(ind.addr.clone(), v); + Ok(v) + }, + Err(e) => { + // ensure the provisional entry doesn't outlive an error + self.env.is_rec_cache.remove(&ind.addr); + Err(e) + }, + } + } + /// H1: Compute `is_rec` constructively by scanning constructor fields for /// references to any inductive in the mutual block. This verifies the declared /// `is_rec` flag rather than trusting it from Ixon input. @@ -1266,10 +1283,7 @@ impl TypeChecker<'_, M> { lvls: block_us.len() as u64, params: n_block_params, indices: ext_n_indices, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: KId::new( Address::hash(b"synthetic-aux-block"), M::meta_field(Name::anon()), @@ -1305,7 +1319,7 @@ impl TypeChecker<'_, M> { }); if dump_canonical { - log::info!( + eprintln!( "[canonical_aux_order.dump] all0={:?} n_aux={} n_block_params={}", all0_name.map(Name::pretty), pairs.len(), @@ -1313,7 +1327,7 @@ impl TypeChecker<'_, M> { ); for (i, (kid, kconst)) in pairs.iter().enumerate() { let seed = aux_seed_names.get(i).cloned().unwrap_or_else(Name::anon); - log::info!( + eprintln!( " pre-sort[{}] addr={} seed={} member_id_addr={}", i, &kid.addr.hex()[..8], @@ -1321,12 +1335,12 @@ impl TypeChecker<'_, M> { &aux[i].id.addr.hex()[..8] ); if let KConst::Indc { ty, ctors, .. } = kconst { - log::info!(" indc.ty={ty}"); + eprintln!(" indc.ty={ty}"); for (ci, ctor_kid) in ctors.iter().enumerate() { if let Some(KConst::Ctor { ty, .. }) = all_ctor_lookup.get(&ctor_kid.addr) { - log::info!(" ctor[{ci}].ty={ty}"); + eprintln!(" ctor[{ci}].ty={ty}"); } } } @@ -1345,10 +1359,10 @@ impl TypeChecker<'_, M> { )?; if dump_canonical { - log::info!("[canonical_aux_order.dump] post-sort classes:"); + eprintln!("[canonical_aux_order.dump] post-sort classes:"); for (ci, class) in classes.iter().enumerate() { for (mi, (kid, _)) in class.iter().enumerate() { - log::info!(" class[{ci}][{mi}] addr={}", &kid.addr.hex()[..8]); + eprintln!(" class[{ci}][{mi}] addr={}", &kid.addr.hex()[..8]); } } } @@ -1407,7 +1421,7 @@ impl TypeChecker<'_, M> { if !self.recursor_dump_matches_block(block_id, flat) { return; } - log::info!( + eprintln!( "[recursor.dump] {label} flat aux order for {block_id}: originals={} aux={}", n_originals, flat.len().saturating_sub(n_originals) @@ -1415,11 +1429,9 @@ impl TypeChecker<'_, M> { for (aux_i, member) in flat.iter().skip(n_originals).enumerate() { let spec = member.spec_params.iter().map(|e| format!("{e}")).collect::>(); - log::info!( + eprintln!( " aux[{aux_i:2}] id={} own_params={} indices={} spec={spec:?}", - member.id, - member.own_params, - member.n_indices + member.id, member.own_params, member.n_indices ); } } @@ -1530,18 +1542,18 @@ impl TypeChecker<'_, M> { failed_gen_major: Option<&KExpr>, failed_stored_major: Option<&KExpr>, ) { - log::info!( + eprintln!( "[recursor.align] FAIL ind_block={ind_block_id} rec_block={rec_block_id} \ peers={} flat={} rec_ids={} failed_gi={failed_gi}", generated_snapshot.len(), flat.len(), rec_ids.len() ); - log::info!( + eprintln!( " failed gen major: {}", Self::major_domain_signature_text(failed_gen_major) ); - log::info!( + eprintln!( " failed stored major: {}", Self::major_domain_signature_text(failed_stored_major) ); @@ -1571,18 +1583,18 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", None => None, }; let mark = if gi == failed_gi { "!!" } else { " " }; - log::info!( + eprintln!( " {mark} peer[{gi:2}] flat.id={} target={}… aux={} ind={}…", flat[gi].id, &target_addr.hex()[..8], flat[gi].is_aux, &gen_rec.ind_addr.hex()[..8] ); - log::info!( + eprintln!( " gen : {}", Self::major_domain_signature_text(gen_major.as_ref()) ); - log::info!( + eprintln!( " sto : {} (rid={})", Self::major_domain_signature_text(stored_major.as_ref()), rid @@ -1601,9 +1613,9 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", return Ok(false); } if depth > 80 { - log::info!("[rule rhs diff] first diff {path}: recursion limit"); - log::info!(" gen: {lhs}"); - log::info!(" sto: {rhs}"); + eprintln!("[rule rhs diff] first diff {path}: recursion limit"); + eprintln!(" gen: {lhs}"); + eprintln!(" sto: {rhs}"); return Ok(true); } @@ -1619,9 +1631,9 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", ExprData::All(_, _, rty, rbody, _), ) => { if !self.is_def_eq(lty, rty)? { - log::info!("[rule rhs diff] first diff {path}.dom"); - log::info!(" gen: {lty}"); - log::info!(" sto: {rty}"); + eprintln!("[rule rhs diff] first diff {path}.dom"); + eprintln!(" gen: {lty}"); + eprintln!(" sto: {rty}"); return Ok(true); } let saved = self.lctx.len(); @@ -1649,9 +1661,9 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", self.dump_rule_rhs_first_diff(la, ra, &format!("{path}.arg"), depth + 1) }, _ => { - log::info!("[rule rhs diff] first diff {path}"); - log::info!(" gen: {lw}"); - log::info!(" sto: {rw}"); + eprintln!("[rule rhs diff] first diff {path}"); + eprintln!(" gen: {lw}"); + eprintln!(" sto: {rw}"); Ok(true) }, } @@ -2129,7 +2141,7 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", pub fn is_large_eliminator( &mut self, result_level: &KUniv, - ind_infos: &[(KId, u64, u64, Vec>, KExpr, bool)], + ind_infos: &[(KId, u64, u64, Vec>, KExpr)], ) -> Result> { // Case 1: non-Prop → always large. // Use is_never_zero() (not !is_zero()) so that Param(u) — which CAN be @@ -2141,7 +2153,7 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", if ind_infos.len() != 1 { return Ok(false); } - let (_, n_params, _, ref ctors, _, _) = ind_infos[0]; + let (_, n_params, _, ref ctors, _) = ind_infos[0]; let n_params = u64_to_usize::(n_params)?; match ctors.len() { // Case 2: 0 constructors → large (Empty/False) @@ -2222,12 +2234,12 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", } // Extract basic info for is_large_eliminator check. - let mut ind_infos: Vec<(KId, u64, u64, Vec>, KExpr, bool)> = + let mut ind_infos: Vec<(KId, u64, u64, Vec>, KExpr)> = Vec::new(); let mut n_params: u64 = 0; for (i, ind_id) in block_inds.iter().enumerate() { match self.get_const(ind_id)? { - KConst::Indc { params, indices, ctors, ty, is_rec, .. } => { + KConst::Indc { params, indices, ctors, ty, .. } => { if i == 0 { n_params = params; } @@ -2237,7 +2249,6 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", indices, ctors.clone(), ty.clone(), - is_rec, )); }, _ => { @@ -2293,7 +2304,7 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", block_first_id.as_ref(), )?; if self.recursor_dump_matches_block(block_id, &flat) { - log::info!("[recursor.dump] canonical_order={canonical_order:?}"); + eprintln!("[recursor.dump] canonical_order={canonical_order:?}"); } // Apply the permutation produced by sort_consts: each canonical // class index k maps to one representative aux from the original @@ -2312,25 +2323,17 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", // Convert flat block to ind_infos format for existing build_motive_type / build_rec_type. // For auxiliary members, we need their type from the environment. - let mut flat_ind_infos: Vec<( - KId, - u64, - u64, - Vec>, - KExpr, - bool, - )> = Vec::with_capacity(flat.len()); + let mut flat_ind_infos: Vec<(KId, u64, u64, Vec>, KExpr)> = + Vec::with_capacity(flat.len()); for m in &flat { let c = self.get_const(&m.id)?; let ty = c.ty().clone(); - let is_rec = matches!(c, KConst::Indc { is_rec: true, .. }); flat_ind_infos.push(( m.id.clone(), m.own_params, m.n_indices, m.ctors.clone(), ty, - is_rec, )); } let flat_ids: Vec> = flat.iter().map(|m| m.id.clone()).collect(); @@ -2393,7 +2396,7 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", let n_motives = flat.len() as u64; let n_minors: u64 = flat.iter().map(|m| m.ctors.len() as u64).sum(); let prefix_skip = n_params + n_motives + n_minors; - log::info!( + eprintln!( "[recursor.dump] generated recursors for {block_id}: count={} prefix_skip={prefix_skip}", generated.len() ); @@ -2403,7 +2406,7 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", prefix_skip, &g.ind_addr, )?; - log::info!( + eprintln!( " gen[{gi:2}] ind_addr={} {}", &g.ind_addr.hex()[..8], Self::major_domain_signature_text(major.as_ref()) @@ -3028,7 +3031,7 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", fn build_rec_type( &mut self, di: usize, - ind_infos: &[(KId, u64, u64, Vec>, KExpr, bool)], + ind_infos: &[(KId, u64, u64, Vec>, KExpr)], block_inds: &[KId], flat: &[FlatBlockMember], _elim_level: &KUniv, @@ -3085,7 +3088,7 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}", // --- Minors: built inline at the correct depth --- // motive_base = depth after pushing params (motives start here) let motive_base = u64_to_usize::(self.depth())? - n_motives; - for (j, (_, _, _, j_ctors, _, _)) in ind_infos.iter().enumerate() { + for (j, (_, _, _, j_ctors, _)) in ind_infos.iter().enumerate() { let j_member = flat[j].clone(); for ctor_id in j_ctors { let minor_ty = self.build_minor_at_depth( @@ -4216,17 +4219,15 @@ re-run with `IX_RECURSOR_DUMP={}` for the full breakdown.", .or_else(|| generated.iter().position(|g| g.ind_addr == ind_id.addr)); if self.recursor_dump_matches_id(id) { - log::info!( + eprintln!( "[recursor.dump] check {} rec_block={} resolved_block={} stored_pos={stored_pos:?} selected_idx={selected_idx:?}", - id, - rec_block, - resolved_block + id, rec_block, resolved_block ); - log::info!( + eprintln!( "[recursor.dump] stored major: {}", Self::major_domain_signature_text(stored_major.as_ref()) ); - log::info!("[recursor.dump] signature_matches={signature_matches:?}"); + eprintln!("[recursor.dump] signature_matches={signature_matches:?}"); for (gi, g) in generated.iter().enumerate() { if g.ind_addr != ind_id.addr { continue; @@ -4236,7 +4237,7 @@ re-run with `IX_RECURSOR_DUMP={}` for the full breakdown.", prefix_skip, &g.ind_addr, )?; - log::info!( + eprintln!( " cand[{gi:2}] {}", Self::major_domain_signature_text(major.as_ref()) ); @@ -4289,11 +4290,11 @@ re-run with `IX_RECURSOR_DUMP={}` for the full breakdown.", } else { "idx/major" }; - log::info!( + eprintln!( "[type diff] binder {bi} ({label}) DIFFERS (p={params} m={motives} min={minors})" ); - log::info!(" gen: {gd}"); - log::info!(" sto: {sd}"); + eprintln!(" gen: {gd}"); + eprintln!(" sto: {sd}"); break; } let _ = self.push_fvar_decl_anon(gd.clone()); @@ -4302,9 +4303,9 @@ re-run with `IX_RECURSOR_DUMP={}` for the full breakdown.", bi += 1; }, _ => { - log::info!("[type diff] return differs at {bi}"); - log::info!(" gen: {gc}"); - log::info!(" sto: {sc}"); + eprintln!("[type diff] return differs at {bi}"); + eprintln!(" gen: {gc}"); + eprintln!(" sto: {sc}"); break; }, } @@ -4380,12 +4381,12 @@ re-run with `IX_RECURSOR_DUMP={}` for the full breakdown.", "rhs", 0, ); - log::info!( + eprintln!( "[rule rhs diff] rule {ri} RHS mismatch (fields={})", gen_rule.fields ); - log::info!(" gen: {}", gen_rule.rhs); - log::info!(" sto: {}", stored_rule.rhs); + eprintln!(" gen: {}", gen_rule.rhs); + eprintln!(" sto: {}", stored_rule.rhs); } return Err(TcError::Other(format!( "check_recursor: rule {ri} RHS mismatch" @@ -4569,10 +4570,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block.clone(), member_idx: 0, ty: sort1(), @@ -4746,10 +4744,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: block.clone(), member_idx: 0, ty: sort1(), @@ -4945,10 +4940,7 @@ mod tests { lvls: 1, params: 1, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: block.clone(), member_idx: 0, ty: list_ty, @@ -5082,10 +5074,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 1, block: tree_block.clone(), member_idx: 0, ty: sort1(), @@ -5135,10 +5124,7 @@ mod tests { lvls: 1, params: 1, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: mk_id("List"), member_idx: 0, ty: list_ty, @@ -5386,10 +5372,7 @@ mod tests { lvls: 1, params: 1, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 1, block: block.clone(), member_idx: 0, ty: ptree_ty, @@ -5448,10 +5431,7 @@ mod tests { lvls: 1, params: 1, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: mk_id("List"), member_idx: 0, ty: list_ty, @@ -5601,10 +5581,7 @@ mod tests { lvls: 2, params: 2, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: mk_id("Pair"), member_idx: 0, ty: pair_ty, @@ -5651,10 +5628,7 @@ mod tests { lvls: 1, params: 1, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: mk_id("List"), member_idx: 0, ty: list_ty, @@ -5711,10 +5685,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 1, block: block.clone(), member_idx: 0, ty: sort1(), @@ -5964,10 +5935,7 @@ mod tests { lvls: 1, params: 1, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: mk_id("Array"), member_idx: 0, ty: arr_ty, @@ -6008,10 +5976,7 @@ mod tests { lvls: 1, params: 1, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: mk_id("List"), member_idx: 0, ty: list_ty, @@ -6069,10 +6034,7 @@ mod tests { lvls: 1, params: 1, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 1, block: block.clone(), member_idx: 0, ty: inl_ty, @@ -6311,10 +6273,7 @@ mod tests { lvls: 1, params: 1, indices: 1, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: block.clone(), member_idx: 0, ty: ok_ty, @@ -6512,10 +6471,7 @@ mod tests { lvls: 0, params: 1, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: wrap_block.clone(), member_idx: 0, ty: wrap_ty, @@ -6560,10 +6516,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: evil_block.clone(), member_idx: 0, ty: sort1(), @@ -6624,10 +6577,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: true, - is_refl: false, is_unsafe, - nested: 0, block: block.clone(), member_idx: 0, ty: sort1(), @@ -6694,10 +6644,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: tree_block.clone(), member_idx: 0, ty: sort1(), @@ -6851,10 +6798,7 @@ mod tests { lvls: 0, params: 1, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block.clone(), member_idx: 0, ty: m1_ty, @@ -6875,10 +6819,7 @@ mod tests { lvls: 0, params: 1, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block.clone(), member_idx: 1, ty: m2_ty, @@ -6916,10 +6857,7 @@ mod tests { lvls: 0, params: 1, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block.clone(), member_idx: i as u64, ty: shared_ty.clone(), @@ -6957,10 +6895,7 @@ mod tests { lvls: 0, params: 1, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block.clone(), member_idx: 0, ty: pi(sort1(), sort1()), @@ -6977,10 +6912,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block.clone(), member_idx: 1, ty: sort1(), diff --git a/crates/kernel/src/infer.rs b/crates/kernel/src/infer.rs index e65748eb..8821e408 100644 --- a/crates/kernel/src/infer.rs +++ b/crates/kernel/src/infer.rs @@ -42,7 +42,7 @@ impl TypeChecker<'_, M> { if *IX_INFER_COUNT_LOG { let n = INFER_COUNT.fetch_add(1, std::sync::atomic::Ordering::Relaxed); if n.is_multiple_of(100_000) && n > 0 { - log::info!("[infer] count={n}"); + eprintln!("[infer] count={n}"); } } let infer_only = self.infer_only; @@ -111,27 +111,27 @@ impl TypeChecker<'_, M> { let f_ty = self.infer(f)?; let (dom, cod) = self.ensure_forall(&f_ty).inspect_err(|_err| { if *IX_INFER_APP_FORALL_DUMP && self.debug_label_matches_env() { - log::info!("[infer App] ensure_forall FAILED"); - log::info!( + eprintln!("[infer App] ensure_forall FAILED"); + eprintln!( " const: {}", self.debug_label.as_deref().unwrap_or("") ); - log::info!(" f: {f}"); - log::info!(" f_ty: {f_ty}"); - log::info!(" f_ty addr: {:?}", f_ty.addr()); - log::info!(" a: {a}"); + eprintln!(" f: {f}"); + eprintln!(" f_ty: {f_ty}"); + eprintln!(" f_ty addr: {:?}", f_ty.addr()); + eprintln!(" a: {a}"); if let ExprData::App(ff, fa, _) = f.data() { - log::info!(" ff: {ff}"); - log::info!(" ff addr: {:?}", ff.addr()); + eprintln!(" ff: {ff}"); + eprintln!(" ff addr: {:?}", ff.addr()); if let Ok(ff_ty) = self.infer(ff) { - log::info!(" ff_ty: {ff_ty}"); - log::info!(" ff_ty addr: {:?}", ff_ty.addr()); + eprintln!(" ff_ty: {ff_ty}"); + eprintln!(" ff_ty addr: {:?}", ff_ty.addr()); if let Ok((dom2, cod2)) = self.ensure_forall(&ff_ty) { - log::info!(" ff_ty dom: {dom2}"); - log::info!(" ff_ty cod: {cod2}"); + eprintln!(" ff_ty dom: {dom2}"); + eprintln!(" ff_ty cod: {cod2}"); } } - log::info!(" fa: {fa}"); + eprintln!(" fa: {fa}"); } } })?; @@ -158,27 +158,27 @@ impl TypeChecker<'_, M> { .ok() .and_then(|s| s.parse::().ok()) .unwrap_or(2); - log::info!( + eprintln!( "[app diff] AppTypeMismatch at depth={}", self.ctx.len() ); - log::info!(" f: {}", compact_expr(f)); - log::info!(" a: {}", compact_expr(a)); - log::info!(" a_ty: {}", compact_expr_deep(&a_ty, depth)); - log::info!(" dom: {}", compact_expr_deep(&dom, depth)); - log::info!(" a_ty data: {:?}", a_ty.data()); - log::info!(" dom data: {:?}", dom.data()); + eprintln!(" f: {}", compact_expr(f)); + eprintln!(" a: {}", compact_expr(a)); + eprintln!(" a_ty: {}", compact_expr_deep(&a_ty, depth)); + eprintln!(" dom: {}", compact_expr_deep(&dom, depth)); + eprintln!(" a_ty data: {:?}", a_ty.data()); + eprintln!(" dom data: {:?}", dom.data()); match &a_whnf { Ok(w) => { - log::info!(" a_ty whnf: {}", compact_expr_deep(w, depth)) + eprintln!(" a_ty whnf: {}", compact_expr_deep(w, depth)) }, - Err(e) => log::info!(" a_ty whnf: ERR {e}"), + Err(e) => eprintln!(" a_ty whnf: ERR {e}"), } match &d_whnf { Ok(w) => { - log::info!(" dom whnf: {}", compact_expr_deep(w, depth)) + eprintln!(" dom whnf: {}", compact_expr_deep(w, depth)) }, - Err(e) => log::info!(" dom whnf: ERR {e}"), + Err(e) => eprintln!(" dom whnf: ERR {e}"), } } return Err(TcError::AppTypeMismatch { @@ -241,14 +241,14 @@ impl TypeChecker<'_, M> { let fv_id = self.fresh_fvar_id(); let fv = self.intern(KExpr::fvar(fv_id, name.clone())); if crate::env_var("IX_FVAR_TRACE").is_ok() { - log::info!( + eprintln!( "[fvar All push] fv={fv_id} ty.addr={:?} ty.lbr={} ctx_len_before_push={} body.lbr={}", ty.addr(), ty.lbr(), self.ctx.len(), body.lbr(), ); - log::info!(" ty data: {:?}", ty.data()); + eprintln!(" ty data: {:?}", ty.data()); } self.lctx.push( fv_id, diff --git a/crates/kernel/src/ingress.rs b/crates/kernel/src/ingress.rs index 13045abf..d1d5e809 100644 --- a/crates/kernel/src/ingress.rs +++ b/crates/kernel/src/ingress.rs @@ -1859,10 +1859,7 @@ fn ingress_muts_inductive( lvls: ind.lvls, params: ind.params, indices: ind.indices, - is_rec: ind.recr, - is_refl: ind.refl, is_unsafe: ind.is_unsafe, - nested: ind.nested, block: block_id, member_idx, ty: typ, @@ -2861,10 +2858,7 @@ fn lean_const_to_kconst( lvls: pn.len() as u64, params: v.num_params.to_u64().unwrap_or(0), indices: v.num_indices.to_u64().unwrap_or(0), - is_rec: v.is_rec, - is_refl: v.is_reflexive, is_unsafe: v.is_unsafe, - nested: v.num_nested.to_u64().unwrap_or(0), block: lean_block_id(self_name, all, n2a), member_idx: lean_member_idx(self_name, all), ty: expr_to_k(&v.cnst.typ, pn), @@ -4350,10 +4344,7 @@ fn ingress_anon_inductive( lvls: ind.lvls, params: ind.params, indices: ind.indices, - is_rec: ind.recr, - is_refl: ind.refl, is_unsafe: ind.is_unsafe, - nested: ind.nested, block: block_id, member_idx, ty: typ, diff --git a/crates/kernel/src/primitive.rs b/crates/kernel/src/primitive.rs index 3ffa1c48..f1000956 100644 --- a/crates/kernel/src/primitive.rs +++ b/crates/kernel/src/primitive.rs @@ -273,111 +273,111 @@ impl PrimAddrs { }; PrimAddrs { nat: h( - "fc0e1e912f2d7f12049a5b315d76eec29562e34dc39ebca25287ae58807db137", + "398a7706cf13f223992d173dce07946857240f49afcc743723e839f8f3f2b631", ), nat_zero: h( - "fac82f0d2555d6a63e1b8a1fe8d86bd293197f39c396fdc23c1275c60f182b37", + "d397370157fb9ae2c6e1eda79feb10bf497401741aba788fab726cfa4c467db6", ), nat_succ: h( - "7190ce56f6a2a847b944a355e3ec595a4036fb07e3c3db9d9064fc041be72b64", + "def52d1dad5f10cf9893c945e169718d62b15e2dd2c9066e597b9d4570ba056e", ), nat_add: h( - "9d83307d552e681f4cceff7f783b5a64e002575edcb1c04fa0c5662ce2dd3438", + "d6f62a9779108f9fb6b66b31cc94c3d84ca72d8bea185e13137c50c7ef84c969", ), nat_pred: h( - "4ed5fffb03ae5e6b7a0d9f3379aa769e5ca8188cacbdf1e20dca4bad27f25333", + "914f9c01884853652e9224dc511f867d5408517f3beb3192fc4477e0e9594c88", ), nat_sub: h( - "9e86ff43b15aebafb3df610a96dd4492ff9cd8aab87a82025b617c9a0bbf6280", + "fdbd5fef40149c85333c6f3ccebb4be741270d2066336cb2eef87623744b72b0", ), nat_mul: h( - "9bc13539b68b0e1c5a53818580aa096a65907f63af4588a1e91e14d34d9e4d86", + "6649665607b0750c2ca73f45de600f21cb670398504865bb97972438014f96d9", ), nat_pow: h( - "b52c4d0d3878f287719f65d0088a269af0f6e5b1b7ef5629830963dcb75e6cee", + "33c604451d01cb19a433668246b98f6e874bd630b78a791d7a373a979849a1cf", ), nat_gcd: h( - "7436d9fa7cce3ef91bc9903cc5aa32d413da2f6ca7c21a9235b41a2fc482dffc", + "3be48357ae17f74d4df27d697aed3f47c1307941f41affcf74da5f66d511a797", ), nat_mod: h( - "6ea1a44f7378e372feb58fb52c8084626057b3f387495e7600b971a38b244276", + "5179638b82cc8337914a7bcaad858c85888844e9a292430cac51e5eadc41a1af", ), nat_div: h( - "d0919570f8932ddf5dff4300ab7667d1baab9324dbc136ac9c81292ed1c81fe9", + "89deca86dd8f0066a5064fdb19a2c6897a3a9867caadc04f778d5c5cd0225362", ), nat_bitwise: h( - "0b69fbfb2ef3c7733ad2f6bd7707820c32603a79603501a77fbbef74df855a32", + "d2075e323bed82f23eaf75ebc0fae4ceb80794240c046b90c51a94d07f5e885f", ), nat_beq: h( - "49a16714bd7b82037cd8e776331d8262829bc70c8ee363c866c7060bf366cd9b", + "a34ab2daba34839e851fa3675124566f9f4dcde597349ecd54ae32f8424e44b8", ), nat_ble: h( - "f5bb245767fdbc683bee9e1ca8d9a7247426fb24c67b2c3f227de51b5f839b26", + "de0befa84faa22d1394379a0ba67296e116660f781b4eb639dbbaba200ef2bf8", ), nat_land: h( - "44514320bd9335a08942e77de8077e383f11a0f6150c000c9823c87467589965", + "818abb331150400d10b34fae4dfb9426741c4607baeed8d96271ba1659058ef8", ), nat_lor: h( - "184ca6a932a4c5fd0a2c169501d2d5048bb743bd166f96ffec9d4101e54e982b", + "9b76f32bbb1dbdf4ff68e0221225015df0ca2d2a6023c1a81306d4020d4ef397", ), nat_xor: h( - "163a8c2800ca51daaffe1b71575127942a05300440524b145c8fcdcc5ee008b6", + "97e325a96a6a1827194eeb7d2aa0d91921073aef9c2d333c24613e9ac956ed29", ), nat_shift_left: h( - "16bd10365ee6fa40b4a1ddc0dd26c8a49db8f8b1eb56b2ac2a179ea2440598d7", + "dc81e41cad1190377dbe604bfc3afe658a413b9a2dcfbcab79fad7b7a5cdd954", ), nat_shift_right: h( - "6fe21e35a9a308deafe53210db5b2856c185dc147ef2717c0e73a0fa3ad31690", + "6db49304bf0f5acbfd1d9d9a0c1b7ae20ef99d0737887056129f5b5cb5a9ba8a", ), bool_type: h( - "6405a455ba70c2b2179c7966c6f610bf3417bd0f3dd2ba7a522533c2cd9e1d0b", + "e6eba3c8b4d19f6a1076b39fa89aec61dccbb960f83d9a62e6acf35a69c9a0a4", ), bool_true: h( - "420dead2168abd16a7050edfd8e17d45155237d3118782d0e68b6de87742cb8d", + "a29a636176cf1135d077eb074798f9007c78e7801383e9cff363bae5edf05762", ), bool_false: h( - "c127f89f92e0481f7a3e0631c5615fe7f6cbbf439d5fd7eba400fb0603aedf2f", + "dda12bcb330727f6dfb816bc9752aabd0520e6515b79fc8a5a9e713866f4c63e", ), string: h( - "422658d043ee482f7102d2f6ea6596664808e899abad628080478a1e9189f0aa", + "7ab2d52ac52fd1f51809b718e53cd058ac4b50d65150e78ae619139ccf13c8fd", ), string_mk: h( - "405d36f5f6479c40216ff7bbba10b077848ec33af03ef4040bfa4f82930de4ba", + "9671fd4fcfbc061c93c2824864cf03124ffee7cc22308de12a7c826473e49906", ), char_type: h( - "2f96b8da29a38b177fc32553d538d5d450212fd3e6fed95d61c817837d29a34f", + "29dd2d1986a525bdde49b4ad2defc349cec71d0484cd13f2da92f1fce89a4c79", ), char_mk: h( - "316fe91ede33079f2330cc9921ee117f9aca023efa14f5b1fe024ddbe625fe86", + "97afa5ad3d86895e6d155019b66c256cd1aa862b4e3c89d8c6580b61939ee541", ), char_of_nat: h( - "28dc1b3d3d2e011529c71c9d4418248f6060dbfb1c7e97db1c572a565787ef61", + "1a4c66f76760f5ef386de089682a55b752131e14a08557c4465ed17fe0c4dc86", ), // NOTE: `String.ofList` and `String.mk` share the canonical content-hash // because both compile to the same Ixon form (a one-constructor `String` // built from `List Char`). The Lean-side deprecation of `String.mk` in // favor of `String.ofList` is orthogonal to the compiled representation. string_of_list: h( - "405d36f5f6479c40216ff7bbba10b077848ec33af03ef4040bfa4f82930de4ba", + "9671fd4fcfbc061c93c2824864cf03124ffee7cc22308de12a7c826473e49906", ), string_to_byte_array: h( - "a07736ec999fdcb8753067497f9f97b461f2a14e8169cd11287dc73cdfd742aa", + "ed43c77e555593b6cd0d4bfbc4273ba122e1c0cdf1090571612a952f941eadb1", ), byte_array_empty: h( - "c07f1589bd7dcc556e384e42bab142a84f7a6255d39b59b0f900198047252296", + "7cfba8fa95847c213aa4066110ba01a97fb597daf29f5c07f72366072f250744", ), list: h( - "abed9ff1aba4634abc0bd3af76ca544285a32dcfe43dc27b129aea8867457620", + "144e207a88d1dfbde22a1b40689033b3a65a652c8f7500b9be3cb7f66366e0fe", ), list_nil: h( - "0ebe345dc46917c824b6c3f6c42b101f2ac8c0e2c99f033a0ee3c60acb9cd84d", + "258a7364b87c99fe9f83e05e0d05c935609a0dc5df8d77939130efe5e0efca3e", ), list_cons: h( - "f79842f10206598929e6ba60ce3ebaa00d11f201c99e80285f46cc0e90932832", + "77d519259ec9fa489dbe0e3dc0b9352aef349ccdaa73ea58b08bb0bc683502a0", ), - eq: h("9c0af2a393cb5c0835e44e60e4c3e68eeb266fd16affad3216096a35fe91b9c1"), + eq: h("036b63d5cc0961e920dee50e7364ec0dd3f9c38a9cace40e513b3835dec8e0c9"), eq_refl: h( - "1e251198f30625628e2eb0983f7be9efe8d719a104a861f2bef2f47eabeed4f9", + "6c9bd60e1eae938e5626ca237dbca7fd950f2e99e234a99c23cfdc294ca7adce", ), quot_type: h( "ab682c1778a17bbeae4032974df36447ce8bfcab6764a36d378566e3ad63cab8", @@ -386,16 +386,16 @@ impl PrimAddrs { "88266677fee774d109867e4b2240281aa2ee12d97920c1171cf5c1f6c87decf6", ), quot_lift: h( - "aa57e8c3f4f9e1cf6b02a038ac158198c3af4b28d61cea7995bf5ca7c7b82c29", + "8dc4a97527812f8b7817b77cd079ace61450aa0185ac5885661ec2acba8b7bd0", ), quot_ind: h( "124984bcb95208a0f30bb69d6736d3d59404e115e2202043fda3d34e01b0ad16", ), reduce_bool: h( - "6e453a7cedafe2edbbc1f0503442be499e4cbf18a6c00dc99f3903ee7f05dbaf", + "1c170098e23143fd8fd6172cefd2ecee305072d2991113cfc4d52840a5a9fa78", ), reduce_nat: h( - "5419187fbf67ef1c4ff9ab0be1b01d4631a270647ffe434bf7e1f788b3c81dd4", + "16853076b0d96d356d85485c56f3398014b6a0f2ee72ab16284a381d9c28e560", ), // Synthetic kernel-only marker. This is intentionally not the compiled // Lean content hash: `eagerReduce` canonicalizes to the same content @@ -405,155 +405,155 @@ impl PrimAddrs { "ff00000000000000000000000000000000000000000000000000000000000003", ), system_platform_num_bits: h( - "d483966438ad47ce4155b3485819a377e22605b59a1aafd0b681cb38aca83107", + "cf86263521d345c39076473ecdb9f6fd411b5b503bce83e2318ba3fb6f2376d8", ), system_platform_get_num_bits: h( - "ad44c90449faf86f63c170f092e2249bccab1e741c1fe10df84c95b44b384371", + "f5d256c1dd794d02cfdf1762c9e41b13abe5bddde12d929d02ada37e4f40e85f", ), subtype_val: h( - "ad58c3656044d7faef697637f516d72674d35b18663cb263f7ccca8cdd2e6f00", + "0b5958a3c822c99e8643a27f0b928dfb82c45447bee0353c200ad1b7d0e46092", ), nat_dec_le: h( - "e2d8292e1adf54b0d39300847718dc89a63332e8f31b41c9e80f8c9a2017278d", + "ec1f60c1a28d48bc98fe3ef72d255132735a503cc36e3ff0f22e3d486e266ebe", ), nat_dec_eq: h( - "8629519632e18c49097936fc220c9e03d6263fddeba4462af5b717dd11e4bef4", + "b4b26c2e29931c06e885914613faff5856138e5cb09620ddb6921a342ded8957", ), nat_dec_lt: h( - "4295c071a9485af2d998e3947be5988077531f02bf091b870d53ce589d4ef5b1", + "c013c153ebf02028aed264333c1e4c85017d0b87025d7596a96971bb2b67921d", ), decidable_rec: h( - "7a18ca84a113b0c2ad0cc0e825a55d767e77a89e8d0e1d82eb9104859f53d095", + "ab3776985743af13a9cb1a7d2f8496997892e17983d14be5270a716570b35719", ), decidable_is_true: h( - "3ae2c71da2bf34179a5a8808857c34a3b7662ff5654d8c247c43e85a7cde493f", + "0f9ee8d9033d8f7b852f5b7152fd124f7d411930c992e0f457f8104b60a98381", ), decidable_is_false: h( - "10ac5f48798b3ff01b0f74c0b544d22796c9775f6d43d328316bbb3aa1638999", + "0471e47158b2ae18d3c08dd5c77aae23e62d7bbc1e61116bc2813b1306bc5795", ), nat_le_of_ble_eq_true: h( - "bab37a8bd9860d3bfe31f1a1752fe7008a224c6ad8af623c7fb8bd192be5c07e", + "21e0e0783b7617b0cc4eff4d1fab7cffefe01cd43da77e2f98d15094a0d8f086", ), nat_not_le_of_not_ble_eq_true: h( - "981b00b7c45899f726c3de35328074cb3f72a09225743da81f5031ff6e647ba9", + "0183595b837b9b84da5f004b8ac4a4bbd3bc0628b99c8d550eb351f74ce16d48", ), nat_eq_of_beq_eq_true: h( - "a57b8180288701cebfb1d6dd29f160cc4acc3c6aba9834e46b65f1c5aa7217e2", + "9ce6e322f19481f21cf4c48f88789876b69b8a9b1520439c101d983f96ea60b7", ), nat_ne_of_beq_eq_false: h( - "6e9b3c1ca5d9f09b902321b155edf4524c3e32de1d690db917bfbaaaac3f8f82", + "3cf54d333821dd37683a0bf38739e687610a1991759220b77edec338ba3cfbc8", ), fin: h( - "272aa9e16c03e9ad7337e706d73efd14ccf1da10e2f8367dd34374b60e1556fa", + "745936fcb9d86c4457f0fd1e537e67077f46f7841108419dac7984008b565b97", ), bool_no_confusion: h( - "5b94718322c633ad163592db4fb7432360f5d023adfa7749f5cf5175798d16ca", + "cd983a826c1e20c4570afca244916c79e20e816f618ffdda38be8a79079274ce", ), // Int primitives — canonical content-hashes from // `lake test -- rust-kernel-build-primitives`. int: h( - "e7dc2d5a2e153e1ab0c78797bcbfd53a2c01ff40918877cfad8ade8c4169a43a", + "a5ca2e1d5ceb8d43367bc34d69a50c1650a25dc10780aa0c378cdfa931ff0424", ), int_of_nat: h( - "46b5eb6768c1f49587d653c12e37338912153386832f0fd0e472484e26322632", + "09bc253147c36ce22c8e0ccd43c79b2cdae2206e0ddd168fca3609b2a584d3dc", ), int_neg_succ: h( - "25bbcd756b52eb78bce170410defa4c15b238dedef5f7b89691621dcbe919780", + "267c0a9c92e75638fc73ed52a9f9c81647eeeceeff2144c1f97e65e2aff149f1", ), int_add: h( - "e4adffd6df782a658a014fc10d5783078ab08df86c6dfa98abf0467f1eff1778", + "ca99084c9d2fcb4c5dd139aecaf159ebd04992d76230cb930f41b86074684817", ), int_sub: h( - "117a355713696bfe4a5e52303e09a64402169ed0e47ca3286ddac66829d0c909", + "d3141231800e012e8db7c240f794e4929bfd156b3845e22f1cf31d3fe39aecd9", ), int_mul: h( - "55a20a6208057a7b3e7fdc0422c44426c09795fd4ab7bc8416693d1929feddd8", + "482064e35634a95c0f252de73d687c24764ea4fa7dfd14cf7af8aa7531f17a5c", ), int_neg: h( - "cda7d330fc5071197cb6237132aef80504cfc2cfa8079cfd1eab8758e9962054", + "f61c7d3fce595430f86f0cd52da5bcb00bf910edd85e14dc0402130fcce34ebd", ), int_emod: h( - "2bca87e317612b6b01a6ea2737c96de2c77403949f56cec0814c8fdb73c16844", + "25c267ef44f15007f2d2e0819be6fb64902c33a7d27a6f2c9d61263898953804", ), int_ediv: h( - "b96aac54f81f2f2e30d16b843f9b1bfde70d24a3391dd22edacec651b7885d71", + "49b34dcbff1e60532825ff5af477eb5de9810ee38e0f7a32014d54c8c1a3a3c5", ), int_bmod: h( - "b7ed12c1ce5af35ce2a954ff9dc4aedfcb434ca13139d67033a51df88bdfe004", + "6a6adf0e95b3a4ce18330ee22105712e9a640ee4311b5dd1022a8e0a30cba0af", ), int_bdiv: h( - "e07fe014c7a8148bf5b679684b3731933cd9f5450e8e393a1ff47b5bb31ded0b", + "a4f1d7a3fe5b6b2ef9522fa537f1e622fbb8176f9fb3358c56cebe1a379b6184", ), int_nat_abs: h( - "ea837737db22feb8ed0234ba5d359e82b1a752d352019d291c642fae92e793e9", + "83e3ce8a747520cc248a0dacf9bd1369467e4907e8aaaa433e1b438e1cad7ca4", ), int_pow: h( - "4274644acc93cec33c8ff16f5fb4c9cca63fba1bb0745ff68b941716e9aae2a3", + "73ecccfeab8a63a3a0faf8d71dc77995bda83418b13cd399b1fa571b50b4575e", ), int_dec_eq: h( - "19e01bc9a3264b9b8b940cf172a209bb774ad36f6410fa742f0048046808c0b6", + "83fde38faa1164648e4227975abf2e8c260d7d4ef1c92676214ffe5826c2075d", ), int_dec_le: h( - "7e048ef303ecdc836467cdd4d892f7fe26fbbd7b62ae1d1746543f4e3098c6e1", + "38d60ffa07b50678d0c3bf0c06f86cd7967b35e87ab071bc55899fcbaed4744f", ), int_dec_lt: h( - "6cc2d63da1fd07e2533fcb08cbb38c2d67f7512a7efd15236a4b0e57bb1fcd53", + "5568e799198dad9fab0e784b7a4c58112bfc2688aecebe3c2c6563304210f956", ), punit: h( - "16a2dc76a2cfcc9440f443c666536f2fa99c0250b642fd3971fbad25d531262a", + "2dfc16af01b82b3b91c2ff704409d76236a83f956c0c6e6659a64fe21d76695b", ), pprod: h( - "6e99b086700f2901804a107cad5ef0fe878077b1723f4b824615dd021d4d5157", + "81a422a42b2cb656b9a47e61a4422f89cdb0a0c166035d47bf5e2c2af02175fa", ), pprod_mk: h( - "00ddf26efd5f7e5eee5561c2467b16ac856efcb3a1226544487645dd46208596", + "c9c584da782cdc453306be9a643244fa0bcbfc3b5dbcbafe3f6b9d65df031fed", ), // Names previously matched via `is_const_named` in whnf.rs. // Canonical content-hashes from `lake test -- rust-kernel-build-primitives`. nat_rec: h( - "43619510ee8a583db72b9d71b84e7ea13a198fe33d73963cf0cc1ebf68a68ad6", + "b975152f3f0cd9039433c68f5a5e5455f5cb5d917078baed0118b59067a74ea7", ), nat_cases_on: h( - "28096d7ca6b3f96bd250cc8b8fee00c36bbc36dd1dd2040854041ec13993ba34", + "1917841d2085796dd7ba346de93a579571b5641c33fc400408ec55b5778a9a51", ), bit_vec: h( - "33d94a2d250a1a5aa022e3befdca1c86f45d70071db038eff9b8980dc5160b76", + "698dd593abfb63db362aaef57e70a793044fb657257291ee2c3e997caa423eae", ), bit_vec_to_nat: h( - "f94271482ffdfd7802d42e22271c89e21dee456b050859c5d12e3d1d699bb4ea", + "77a025c19f8be131fb9d5b0bec494817a26538b9a550abbbcec8099fae9de4e4", ), bit_vec_of_nat: h( - "2acb8942f3587d0aebf1795df90426eaff54e7f3ccce36c589d5d14716a78fad", + "90ca8130735c8d9a34005a8943b59fe1df182e08a9f2bfc7dc8323229659a574", ), bit_vec_ult: h( - "068a88410ef445d31ae58e0e11b3684143e472288bd4a884d5f928c3d2019bec", + "9fd8e7459a1d2deef00a4992a50419bac66c03082b58ade07422896f13033d74", ), decidable_decide: h( - "f4cdbc5ed9a1ab5928f9931f5c2390239e7f47df6d20e84ea465c9707b84cdc1", + "c5f7b19663e4499e70e1b2645162c5be15fa860f4f8157e331ae546c6f733723", ), lt_lt: h( - "01d871bcdfb2e769e1aca00e7a3b3a21a8d902cc273707c892eb867b7fc78ae2", + "cacaea97f4cdba0a4a0af71005d0517d1818ab2623bd2ea7fa8c637a0e3d3312", ), of_nat_of_nat: h( - "8fdc869f7b7aa2b7b5929ba242ed899ce2d7c5d42df1d4e2393690cfa85e94d2", + "5a7292ad756ee1f2df4b92f18a27574a47cbbcf7094f98ab2865f92eb22342d7", ), unit: h( - "211bf5ed2f4c51d45750e75b891fa267db4d4e6f46c2079282fa2be3e88781a1", + "9232498667f765f437dedaac828e555f6cc67a20e6db28f614fdf3c262710feb", ), punit_size_of_1: h( - "489187e9cd03abebc12a1335c628d642ea2a48bdc262c85f848f1011e73f610a", + "7bd8e19f47f6eae620a5c39f243ce415dd6a77f09590f4c227cef363007f4012", ), size_of_size_of: h( - "7105eaf4c52ce3a19372a87fac57a8f9598a246334ce6effaee3e48e7e6d3aad", + "389715f91e66683dc7108ccd853efce92949512fa659ad3c1902e754692919cd", ), string_back: h( - "f6066fc62491fd4c48d4daf3b9beba72e2a0b8040fcbd99fb729abf56a9c07c4", + "e95c8d876e7ccf780418615e33b747a245d94facd7567fecbe7ae73a5ac09206", ), string_legacy_back: h( - "d5e543a5b6bde88dc3854d4c2b9a12ac270976bf4102a6b33f55a90db324268f", + "6bb6162aac7d6a01b6ec05580664e8a7f0d4b0ec1fc5afaae66018e9a1936dac", ), string_utf8_byte_size: h( - "cc6cdc73e0df404ba7685c733ebbe7c1aecc6ef46503d10aad58bf70f84a4858", + "def4433d9547b53175e24a3ac182c88b072af0d4ad33fd04ec4cf2ba3d95ea93", ), } } diff --git a/crates/kernel/src/subst.rs b/crates/kernel/src/subst.rs index 58bac969..dc1382e1 100644 --- a/crates/kernel/src/subst.rs +++ b/crates/kernel/src/subst.rs @@ -51,7 +51,7 @@ pub fn subst( if *IX_SUBST_COUNT_LOG && depth == 0 { let n = SUBST_COUNT.fetch_add(1, std::sync::atomic::Ordering::Relaxed); if n.is_multiple_of(100_000) && n > 0 { - log::info!("[subst] count={n}"); + eprintln!("[subst] count={n}"); } } // Fast path: no loose bound vars at or below `depth` means nothing to diff --git a/crates/kernel/src/tc.rs b/crates/kernel/src/tc.rs index 92dd1a23..3252bd51 100644 --- a/crates/kernel/src/tc.rs +++ b/crates/kernel/src/tc.rs @@ -866,7 +866,7 @@ impl<'a, M: KernelMode> TypeChecker<'a, M> { if crate::env_var("IX_REC_FUEL_DUMP").is_ok() && self.debug_label_matches_env() { - log::info!( + eprintln!( "[rec fuel] exhausted const={} depth={} def_eq_depth={} infer_only={} native_reduce={} eager_reduce={}", self.debug_label.as_deref().unwrap_or(""), self.depth(), @@ -876,7 +876,7 @@ impl<'a, M: KernelMode> TypeChecker<'a, M> { self.eager_reduce ); self.dump_hot_misses(); - log::info!("{}", std::backtrace::Backtrace::force_capture()); + eprintln!("{}", std::backtrace::Backtrace::force_capture()); } return Err(TcError::MaxRecFuel); } @@ -1015,9 +1015,9 @@ impl<'a, M: KernelMode> TypeChecker<'a, M> { } let mut entries: Vec<_> = self.hot_misses.iter().collect(); entries.sort_unstable_by(|a, b| b.1.cmp(a.1).then_with(|| a.0.cmp(b.0))); - log::info!("[hot misses] top {}:", entries.len().min(25)); + eprintln!("[hot misses] top {}:", entries.len().min(25)); for (key, count) in entries.into_iter().take(25) { - log::info!(" {count:>8} {key}"); + eprintln!(" {count:>8} {key}"); } } } diff --git a/crates/kernel/src/tutorial/defeq.rs b/crates/kernel/src/tutorial/defeq.rs index b97f9ee7..703066bf 100644 --- a/crates/kernel/src/tutorial/defeq.rs +++ b/crates/kernel/src/tutorial/defeq.rs @@ -300,10 +300,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort1(), @@ -428,10 +425,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: bool_id.clone(), member_idx: 0, ty: sort1(), @@ -490,10 +484,7 @@ mod tests { lvls: 1, params: 2, indices: 1, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: acc_ty, @@ -863,10 +854,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: bool_id.clone(), member_idx: 0, ty: sort1(), @@ -955,10 +943,7 @@ mod tests { lvls: 1, params: 2, indices: 1, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: eq_id.clone(), member_idx: 0, ty: eq_ty, @@ -1256,10 +1241,7 @@ mod tests { lvls: 0, params: 2, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: npi("a", sort0(), npi("b", sort0(), sort0())), @@ -1424,10 +1406,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort1(), @@ -1600,10 +1579,7 @@ mod tests { lvls: 1, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort_u2, @@ -1703,10 +1679,7 @@ mod tests { lvls: 1, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: pu_id.clone(), member_idx: 0, ty: sort(param(0)), // Sort u @@ -1778,10 +1751,7 @@ mod tests { lvls: 2, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: ps_id.clone(), member_idx: 0, ty: sort0(), // Prop @@ -2102,10 +2072,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: true_ty_id.clone(), member_idx: 0, ty: sort0(), @@ -2174,10 +2141,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: t_id.clone(), member_idx: 0, ty: sort1(), diff --git a/crates/kernel/src/tutorial/inductive.rs b/crates/kernel/src/tutorial/inductive.rs index 67591714..241ded55 100644 --- a/crates/kernel/src/tutorial/inductive.rs +++ b/crates/kernel/src/tutorial/inductive.rs @@ -33,10 +33,7 @@ mod tests { lvls, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: ty.clone(), @@ -130,10 +127,7 @@ mod tests { lvls: 0, params: 2, // claims 2 params indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: pi(sort0(), sort0()), // only 1 arrow — Prop → Prop @@ -188,10 +182,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort1(), @@ -272,10 +263,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort1(), // Type = Sort 1 @@ -366,10 +354,7 @@ mod tests { lvls: 0, params: 1, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: pi(sort0(), sort1()), @@ -453,10 +438,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort1(), @@ -544,10 +526,7 @@ mod tests { lvls: 0, params: 0, indices: 1, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: npi("α", sort1(), sort1()), @@ -642,10 +621,7 @@ mod tests { lvls: 0, params: 2, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: npi("x", sort0(), npi("y", sort0(), sort1())), @@ -742,10 +718,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort1(), @@ -838,10 +811,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort1(), @@ -940,10 +910,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort0(), // Prop @@ -1027,10 +994,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort2, // Type 1 @@ -1117,10 +1081,7 @@ mod tests { lvls: 2, params: 2, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: npi("x", sort0(), npi("y", sort0(), sort1())), @@ -1224,10 +1185,7 @@ mod tests { lvls: 0, params: 0, indices: 1, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: pi(sort0(), sort0()), @@ -1331,10 +1289,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort0(), // Prop @@ -1484,10 +1439,7 @@ mod tests { lvls: 0, params: 1, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: pi(sort1(), sort1()), @@ -1627,10 +1579,7 @@ mod tests { lvls: 0, params: 1, indices: 0, - is_rec: true, - is_refl: true, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: pi(sort1(), sort1()), @@ -1741,10 +1690,7 @@ mod tests { lvls: 0, params: 1, indices: 0, - is_rec: true, - is_refl: true, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: pi(sort1(), sort1()), diff --git a/crates/kernel/src/tutorial/reduction.rs b/crates/kernel/src/tutorial/reduction.rs index aa482201..3edf6788 100644 --- a/crates/kernel/src/tutorial/reduction.rs +++ b/crates/kernel/src/tutorial/reduction.rs @@ -282,10 +282,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort1(), @@ -476,10 +473,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort1(), @@ -755,10 +749,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: true, - is_refl: true, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: sort1(), @@ -1049,10 +1040,7 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: bool_id.clone(), member_idx: 0, ty: sort1(), @@ -1110,10 +1098,7 @@ mod tests { lvls: 2, params: 2, indices: 0, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: block_id.clone(), member_idx: 0, ty: prod_ty, @@ -1379,10 +1364,7 @@ mod tests { lvls: 1, params: 2, indices: 1, - is_rec: false, - is_refl: false, is_unsafe: false, - nested: 0, block: eq_id.clone(), member_idx: 0, ty: eq_ty, diff --git a/crates/kernel/src/whnf.rs b/crates/kernel/src/whnf.rs index 0ca940ab..88001584 100644 --- a/crates/kernel/src/whnf.rs +++ b/crates/kernel/src/whnf.rs @@ -123,7 +123,7 @@ impl TypeChecker<'_, M> { } let (orig_head, orig_args) = collect_app_spine(original); let (cur_head, cur_args) = collect_app_spine(current); - log::info!( + eprintln!( "[whnf fuel] {phase} const={} depth={} original_head={} original_args={} current_head={} current_args={}", self.debug_label.as_deref().unwrap_or(""), self.depth(), @@ -132,8 +132,8 @@ impl TypeChecker<'_, M> { cur_head, cur_args.len() ); - log::info!(" original: {original}"); - log::info!(" current: {current}"); + eprintln!(" original: {original}"); + eprintln!(" current: {current}"); } fn dump_delta_trace(&self, id: &KId, arity: usize, e: &KExpr) { @@ -147,7 +147,7 @@ impl TypeChecker<'_, M> { if !filter.is_empty() && !id_s.contains(filter) { return; } - log::info!( + eprintln!( "[delta] const={} depth={} head={} args={arity} expr={}", self.debug_label.as_deref().unwrap_or(""), self.depth(), @@ -176,7 +176,7 @@ impl TypeChecker<'_, M> { } let (head, args) = collect_app_spine(wval); match result { - Some(result) => log::info!( + Some(result) => eprintln!( "[proj] const={} depth={} proj={} field={} struct_head={} struct_args={} ctor_params={:?} result={}", self.debug_label.as_deref().unwrap_or(""), self.depth(), @@ -187,7 +187,7 @@ impl TypeChecker<'_, M> { ctor_params, result ), - None => log::info!( + None => eprintln!( "[proj] const={} depth={} proj={} field={} struct_head={} struct_args={} ctor_params={:?} result=", self.debug_label.as_deref().unwrap_or(""), self.depth(), @@ -212,7 +212,7 @@ impl TypeChecker<'_, M> { if !filter.is_empty() && !head_s.contains(filter) { return; } - log::info!( + eprintln!( "[nat] const={} depth={} phase={} head={} args={} expr={}", self.debug_label.as_deref().unwrap_or(""), self.depth(), @@ -236,7 +236,7 @@ impl TypeChecker<'_, M> { if *IX_WHNF_COUNT_LOG { let n = WHNF_COUNT.fetch_add(1, std::sync::atomic::Ordering::Relaxed); if n.is_multiple_of(100_000) && n > 0 { - log::info!("[whnf] count={n}"); + eprintln!("[whnf] count={n}"); } } crate::profile::bump_whnf(); @@ -935,7 +935,7 @@ impl TypeChecker<'_, M> { let n = NAT_IOTA_TRACE_COUNT .fetch_add(1, std::sync::atomic::Ordering::Relaxed); if n < 32 { - log::info!( + eprintln!( "[nat_iota_trace] rec={} major_bits={} spine={} major_idx={}", rec_id, val.0.bits(), @@ -979,9 +979,9 @@ impl TypeChecker<'_, M> { if !is_ctor && let Some(filter) = IX_IOTA_STUCK.as_ref() { let rec_name = format!("{rec_id}"); if filter.is_empty() || rec_name.contains(filter) { - log::info!("[iota stuck] rec={rec_name}"); - log::info!("[iota stuck] major: {major}"); - log::info!("[iota stuck] major whnf: {major_whnf}"); + eprintln!("[iota stuck] rec={rec_name}"); + eprintln!("[iota stuck] major: {major}"); + eprintln!("[iota stuck] major whnf: {major_whnf}"); } } @@ -1038,13 +1038,13 @@ impl TypeChecker<'_, M> { Ok(None) } - fn is_struct_like(&mut self, id: &KId) -> Result> { - Ok(match self.try_get_const(id)? { - Some(KConst::Indc { is_rec, indices, ctors, .. }) => { - !is_rec && indices == 0 && ctors.len() == 1 - }, - _ => false, - }) + pub fn is_struct_like(&mut self, id: &KId) -> Result> { + match self.try_get_const(id)? { + Some(KConst::Indc { indices, ctors, .. }) + if indices == 0 && ctors.len() == 1 => {}, + _ => return Ok(false), + } + Ok(!self.computed_is_rec(id)?) } fn apply_iota_arg( @@ -1674,7 +1674,7 @@ impl TypeChecker<'_, M> { let n = NAT_EXPAND_COUNT.fetch_add(1, std::sync::atomic::Ordering::Relaxed); if n.is_multiple_of(10_000) { - log::info!("[nat_to_constructor] count={n} val_bits={}", val.0.bits()); + eprintln!("[nat_to_constructor] count={n} val_bits={}", val.0.bits()); } } if val.0 == BigUint::ZERO { @@ -1869,7 +1869,7 @@ impl TypeChecker<'_, M> { .fetch_add(1, std::sync::atomic::Ordering::Relaxed); if n < 8 { let step_whnf = self.whnf(step)?; - log::info!( + eprintln!( "[nat_linear_rec] major_bits={} base_idx={} step_idx={} spine={} step_whnf={}", parts.major.0.bits(), parts.base_idx, @@ -3333,10 +3333,7 @@ mod tests { lvls: 0, params: 1, indices: 0, - is_rec: true, - is_refl: false, is_unsafe: false, - nested: 0, block: list_id.clone(), member_idx: 0, ty: pi(sort0(), sort0()), @@ -3554,9 +3551,6 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: false, - is_refl: false, - nested: 0, block: block.clone(), member_idx: 0, ty: sort1(), @@ -3650,9 +3644,6 @@ mod tests { lvls: 0, params: 0, indices: 0, - is_rec: true, - is_refl: false, - nested: 0, block: block.clone(), member_idx: 0, ty: sort1(), @@ -4196,7 +4187,7 @@ mod tests { }, ExprData::App(..) => { // Might be Nat.succ chain — that's also acceptable - log::info!("Nat.rec result is App chain (not folded to literal)"); + eprintln!("Nat.rec result is App chain (not folded to literal)"); }, other => panic!("unexpected Nat.rec result: {:?}", other), } From 2fc6dda4fd1c1965d11b9d2be79815c0690a8c44 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Sat, 4 Jul 2026 02:20:28 -0400 Subject: [PATCH 2/5] Compile: evaporated-aux canonicalization and byte-exact aux roundtrip MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Evaporated auxiliaries (over-merge splits): when SCC splitting strands a nested aux's spec-param inductives outside the owner's SCC, no SCC holds the joint family, and dropping the irrelevant over-merged motives leaves exactly the external inductive's generic recursor. Canonical treatment: `rec_N` claims alias `.rec` (e.g. `List.rec`), call sites are rebuilt onto the external telescope via head-rewrite CallSitePlans (owner-gated, single-motive targets), and `below_N`/`brecOn_N` compile as surgered originals like `_sizeOf_N`. Fixes the AuxDedup kernel-check failures (28 -> 0); AuxDedup1 now generates identical auxiliaries to AuxDedup2 (the canonical structure). New AuxDedupMixed fixture covers a perm mixing a canonical slot and PERM_OUT_OF_SCC for the same owner. Documented in docs/ix_canonicity.md 6.5. Call-site surgery guard is now durable across serialization: aux-regen detection accepts `Named.original.is_some()` in addition to the in-memory `aux_name_to_addr`, so deserialized-state roundtrip recompiles no longer misapply surgery. Shift-aware `instantiate_rev` replaces unshifted substitution in the type-walking helpers (fixes fvar leaks in `.brecOn.go` bodies). Byte-exact aux roundtrip: `roundtrip_block` Phase A now preseeds the ref/univ tables (`preseed_expr_tables`) like every production compile path. The serialized constant embeds those tables in sorted order; compiling without the preseed filled them in traversal order instead, permuting every `Ref`/univ index — byte-different but semantically identical constants (decode resolves through the embedded table). This silently failed the Phase-A address comparison against `Named.original.0` for 1529 of 1545 aux constants (including plain stdlib like `Nat.casesOn`); a debug probe proved compile(original) == compile(regen) in every case, i.e. the regeneration itself was always faithful. With the invariant holding corpus-wide, the Phase-A recompile-hash mismatch is now a hard error with no aux exemption, and every roundtrip arm records failures in `aux_gen_errors` (recovery keeps the Lean-facing env populated for diagnosis but is never silent). Pass-2 scope hygiene: the below-def roundtrip loop filters by the original-gated `aux_members` like its sibling loops, so evaporated `below_N` keep their faithful Pass-1 decompile. IX_ROUNDTRIP_DEBUG now dumps hashed component scalars/hashes and runs an original-form recompile probe for any mismatch. Test fixes: kernel-tutorial `bad_raw_consts` inductive fixtures carry recomputation-honest flags so compile-side `validate_ind_flags` no longer poisons the shared tutorial env (73/335 -> 335/335, with the kernel rejecting each bad fixture as designed); validate-aux seeds match module-private fixture names via `privateToUserName?` and enable the Canonicity prefix; Phase 4b gains per-module markers so a fully absent identity group fails loudly when its fixture module is loaded (previously vacuous at 0 pass / 0 fail, now 109 pass). Gates: kernel-check-env 201296/201296; rust-compile all phases with 0 aux_gen errors, 0 mismatches, and 0 Phase-A address divergences on the full 213k env (live and deserialized); validate-aux 0 failures at 4393-constant scope; rust-serialize byte-exact; kernel-ixon-roundtrip 143694/0; kernel-tutorial 335/335; cargo test and lake test green. --- .gitignore | 3 + Tests/Ix/Compile/Mutual.lean | 14 + Tests/Ix/Compile/ValidateAux.lean | 10 +- Tests/Ix/Kernel/TutorialDefs.lean | 33 +- crates/compile/src/compile.rs | 269 ++++++++- crates/compile/src/compile/aux_gen.rs | 103 +++- .../compile/src/compile/aux_gen/expr_utils.rs | 7 +- crates/compile/src/compile/surgery.rs | 482 +++++++++++++++-- crates/compile/src/decompile.rs | 509 ++++++++++++++++-- crates/ffi/src/lean_env.rs | 130 ++++- crates/ixon/src/metadata.rs | 31 +- crates/kernel/src/ingress.rs | 2 + docs/ix_canonicity.md | 67 ++- 13 files changed, 1525 insertions(+), 135 deletions(-) diff --git a/.gitignore b/.gitignore index 2ba25779..c31fc18e 100644 --- a/.gitignore +++ b/.gitignore @@ -7,4 +7,7 @@ # Nix result* .direnv/ + +#Ix *.ixe +plans diff --git a/Tests/Ix/Compile/Mutual.lean b/Tests/Ix/Compile/Mutual.lean index ae83974e..d35be462 100644 --- a/Tests/Ix/Compile/Mutual.lean +++ b/Tests/Ix/Compile/Mutual.lean @@ -485,5 +485,19 @@ end end AuxDedup2 +-- Mixed nested auxiliaries: `List M` stays a genuine nested occurrence of +-- M's split SCC (M is recursive through it), while `List B` evaporates +-- (B splits into its own SCC). Exercises the expand/restore path with a +-- perm mixing a canonical slot and PERM_OUT_OF_SCC for the same owner: +-- `M.rec_1` is a canonical aux patch, `M.rec_2` aliases `List.rec`. +namespace AuxDedupMixed + +mutual + inductive M : Type where | mk : List M → List B → M + inductive B : Type where | leaf : B +end + +end AuxDedupMixed + end Tests.Ix.Compile.Mutual diff --git a/Tests/Ix/Compile/ValidateAux.lean b/Tests/Ix/Compile/ValidateAux.lean index 87feef1b..7837b811 100644 --- a/Tests/Ix/Compile/ValidateAux.lean +++ b/Tests/Ix/Compile/ValidateAux.lean @@ -65,15 +65,21 @@ def runCompileValidateAux (env : Lean.Environment) : IO UInt32 := do IO.println "[validate-aux] finding seeds..." let prefixes := [ `Tests.Ix.Compile.Mutual, - --`Tests.Ix.Compile.Canonicity, + `Tests.Ix.Compile.Canonicity, --`Init, --`_private.Init, --`State, --`Lean, --`Tests.Ix.Kernel.TutorialDefs ] + -- Module-system fixtures declared without `public` get private-mangled + -- names (`_private..0.` — e.g. the AuxDedup namespaces in + -- Tests.Ix.Compile.Mutual). Match prefixes against the user-visible form + -- so those constants are seeded too; otherwise Phase 4b's AuxDedup + -- identity groups are fully absent and silently skipped. let mut seeds := env.constants.toList.filterMap fun (n, _) => - if prefixes.any (·.isPrefixOf n) then some n else none + let visible := (Lean.privateToUserName? n).getD n + if prefixes.any (·.isPrefixOf visible) then some n else none -- Add prereqs that aux_gen references but test fixtures don't directly use. -- .below uses PUnit/PProd (Type-level), .brecOn uses Eq/True. -- We need the full inductive family: type, constructors, and recursor. diff --git a/Tests/Ix/Kernel/TutorialDefs.lean b/Tests/Ix/Kernel/TutorialDefs.lean index b83edca2..cfac0e20 100644 --- a/Tests/Ix/Kernel/TutorialDefs.lean +++ b/Tests/Ix/Kernel/TutorialDefs.lean @@ -692,9 +692,13 @@ bad_raw_consts all := [n] ctors := [n ++ `mk] numNested := 0 - isRec := false + -- Honest flags (the `n → n` ctor field domain is a self-occurrence + -- inside an arrow): the badness under test is the NEGATIVE + -- occurrence, which the kernel must reject — not a compile-side + -- `validate_ind_flags` mismatch (see the `reflOccInIndex` note). + isRec := true isUnsafe := false - isReflexive := false + isReflexive := true } ] @@ -750,9 +754,12 @@ bad_raw_consts all := [n] ctors := [n ++ `mk] numNested := 0 - isRec := false + -- Honest flags (self-occurrence inside an arrow domain; the badness + -- under test is the reducible-hidden negative occurrence — see the + -- `reflOccInIndex` note). + isRec := true isUnsafe := false - isReflexive := false + isReflexive := true } ] @@ -956,9 +963,13 @@ bad_raw_consts all := [n] ctors := [n ++ `mk] numNested := 0 - isRec := false + -- Honest flags (`Nat → n → Nat` field domain contains a + -- self-occurrence and is an arrow): the badness under test is the + -- LEFT-of-arrow occurrence, which the kernel must reject — see the + -- `reflOccInIndex` note. + isRec := true isUnsafe := false - isReflexive := false + isReflexive := true } ] @@ -988,9 +999,15 @@ bad_raw_consts all := [n] ctors := [n ++ `mk] numNested := 0 - isRec := false + -- Honest flags (the ctor field `Nat → I (I α)` makes `I` recursive + -- and reflexive): compile-side `validate_ind_flags` must not be the + -- thing that rejects this fixture — the badness under test is the + -- reflexive occurrence in INDEX position, which the *kernel* must + -- reject. Stale `false` flags here failed the whole shared tutorial + -- env compile, poisoning every other test case. + isRec := true isUnsafe := false - isReflexive := false + isReflexive := true } ] diff --git a/crates/compile/src/compile.rs b/crates/compile/src/compile.rs index 528e915d..d48400ea 100644 --- a/crates/compile/src/compile.rs +++ b/crates/compile/src/compile.rs @@ -644,6 +644,10 @@ pub fn compile_expr( n_canonical: usize, /// Number of collapsed args on the results stack (after canonical args). n_collapsed: usize, + /// True when the LAST collapsed arg is the ORIGINAL (pre-rewrite) head + /// expression of a head-rewritten call site. It gets a + /// `CallSite.orig_head` pointer instead of a source-order entry. + orig_head_collapsed: bool, }, } @@ -773,14 +777,209 @@ pub fn compile_expr( // original's Ixon still lives in `stt.env.consts` and its // arena must be decompile-safe (decompile iterates all // constants). - let compiling_is_aux_regen = cache - .compiling - .as_ref() - .is_some_and(crate::decompile::is_aux_gen_suffix); + // + // The suffix alone is NOT sufficient: an EVAPORATED aux + // (`.below_N` / `.brecOn_N` family whose nested occurrence + // left the SCC) has no regenerated canonical at all — its + // surgered original IS its canonical form, so surgery MUST + // run for it. "Has a regen/alias" is: + // - membership in `aux_name_to_addr` (in-memory compile + // state: every compile_aux_block projection, below ctor, + // and alias registration inserts here — covers the + // original-track compile, which runs BEFORE promote), or + // - `Named.original.is_some()` (durable: set by + // `promote_aux` exactly for regen/aliased names and + // survives serialization — covers decompile-side + // roundtrip recompiles on a DESERIALIZED state, where + // `aux_name_to_addr` is empty and the in-memory check + // alone would wrongly re-enable surgery). + // Evaporated names enter neither. + let compiling_is_aux_regen = + cache.compiling.as_ref().is_some_and(|c| { + crate::decompile::is_aux_gen_suffix(c) + && (stt.aux_name_to_addr.contains_key(c) + || stt + .env + .named + .get(c) + .is_some_and(|n| n.original.is_some())) + }); if !compiling_is_aux_regen { if let Some(plan) = stt.call_site_plans.get(name) && !plan.is_identity() { + // Evaporated-aux head rewrite: the callee's claim is + // aliased to the external inductive's recursor, so the + // over-merged spine is rebuilt onto that telescope — + // specs… motive minors′… indices… major — with the level + // list extended to the target's arity. Dropped args are + // preserved as Collapsed entries for decompile; wrapped + // minors follow the adapted-minor convention below. + if let Some(hr) = plan.head_rewrite.clone() { + let expected_total = plan.n_params + + plan.n_source_motives + + plan.n_source_minors + + plan.n_indices + + 1; // major + if args.len() < expected_total { + return Err(CompileError::InvalidMutualBlock { + reason: format!( + "head-rewrite call site for '{}' is under-applied: \ + {} args, telescope needs {}", + name.pretty(), + args.len(), + expected_total, + ), + }); + } + let lean_env_ref = + stt.lean_env.as_deref().ok_or_else(|| { + CompileError::InvalidMutualBlock { + reason: format!( + "head-rewrite for '{}' requires the Lean env", + name.pretty() + ), + } + })?; + let name_addr = compile_name(name, stt); + let args_owned: Vec = + args.iter().map(|arg| (*arg).clone()).collect(); + let params = &args_owned[..plan.n_params]; + let motives = &args_owned + [plan.n_params..plan.n_params + plan.n_source_motives]; + let minors = &args_owned[plan.n_params + + plan.n_source_motives + ..plan.n_params + + plan.n_source_motives + + plan.n_source_minors]; + let tail = &args_owned[plan.n_params + + plan.n_source_motives + + plan.n_source_minors..]; + let (target_levels, specs) = + surgery::derive_head_rewrite_app( + name, levels, &hr, params, motives, lean_env_ref, + ) + .map_err(|e| CompileError::InvalidMutualBlock { + reason: format!( + "head-rewrite for '{}': {e}", + name.pretty() + ), + })?; + + let mut canonical_args: Vec = + Vec::with_capacity( + specs.len() + 1 + plan.n_canonical_minors() + + tail.len(), + ); + let mut collapsed_args: Vec = Vec::new(); + let mut entries: Vec = Vec::new(); + + // Source params don't appear in the target spine (the + // specs subsume them) — collapse for reconstruction. + for p in params.iter() { + let sharing_idx = collapsed_args.len(); + collapsed_args.push(p.clone()); + entries.push(CallSiteEntry::Collapsed { + sharing_idx: sharing_idx as u64, + meta: 0, + }); + } + let n_specs = specs.len(); + canonical_args.extend(specs.into_iter()); + for (src_i, motive) in motives.iter().enumerate() { + if plan.motive_keep[src_i] { + canonical_args.push(motive.clone()); + entries.push(CallSiteEntry::Kept { + canon_idx: n_specs as u64, + meta: 0, + }); + } else { + let sharing_idx = collapsed_args.len(); + collapsed_args.push(motive.clone()); + entries.push(CallSiteEntry::Collapsed { + sharing_idx: sharing_idx as u64, + meta: 0, + }); + } + } + for (src_i, minor) in minors.iter().enumerate() { + if plan.minor_keep[src_i] { + let canon_pos = canonical_args.len(); + let adapted_minor = surgery::adapt_split_minor( + name, + levels, + &plan, + src_i, + minor, + params, + motives, + minors, + lean_env_ref, + ); + let minor_arg = adapted_minor + .clone() + .unwrap_or_else(|| minor.clone()); + canonical_args.push(minor_arg); + if adapted_minor.is_some() { + let sharing_idx = collapsed_args.len(); + collapsed_args.push(minor.clone()); + entries.push(CallSiteEntry::Collapsed { + sharing_idx: sharing_idx as u64, + meta: 0, + }); + } else { + entries.push(CallSiteEntry::Kept { + canon_idx: canon_pos as u64, + meta: 0, + }); + } + } else { + let sharing_idx = collapsed_args.len(); + collapsed_args.push(minor.clone()); + entries.push(CallSiteEntry::Collapsed { + sharing_idx: sharing_idx as u64, + meta: 0, + }); + } + } + for t in tail.iter() { + let canon_pos = canonical_args.len(); + canonical_args.push(t.clone()); + entries.push(CallSiteEntry::Kept { + canon_idx: canon_pos as u64, + meta: 0, + }); + } + + // Preserve the ORIGINAL head (source name + source + // level args) as the LAST sharing entry so decompile + // can restore it — the stored canonical head carries + // the target recursor's extended level list. + collapsed_args.push(head_expr.clone()); + let n_canonical = canonical_args.len(); + let n_collapsed = collapsed_args.len(); + // The head keeps its SOURCE name (the alias resolves it + // to the external recursor's address and the arena + // records the source name for decompile) but carries + // the target's level list. + let head_for_canon = + LeanExpr::cnst(name.clone(), target_levels); + stack.push(Frame::BuildCallSite { + name_addr, + entries, + n_canonical, + n_collapsed, + orig_head_collapsed: true, + }); + for arg in collapsed_args.iter().rev() { + stack.push(Frame::Compile(arg.clone())); + } + for arg in canonical_args.iter().rev() { + stack.push(Frame::Compile(arg.clone())); + } + stack.push(Frame::Compile(head_for_canon)); + continue; + } let expected_total = plan.n_params + plan.n_source_motives + plan.n_source_minors @@ -917,6 +1116,7 @@ pub fn compile_expr( entries, n_canonical, n_collapsed, + orig_head_collapsed: false, }); for arg in collapsed_args.iter().rev() { stack.push(Frame::Compile(arg.clone())); @@ -1018,6 +1218,7 @@ pub fn compile_expr( entries, n_canonical, n_collapsed, + orig_head_collapsed: false, }); for arg in collapsed_args.iter().rev() { stack.push(Frame::Compile(arg.clone())); @@ -1149,6 +1350,7 @@ pub fn compile_expr( entries, n_canonical, n_collapsed, + orig_head_collapsed: false, }); for arg in collapsed_args.iter().rev() { stack.push(Frame::Compile(arg.clone())); @@ -1244,9 +1446,9 @@ pub fn compile_expr( stack.push(Frame::Compile(inner.clone())); }, - ExprData::Fvar(..) => { + ExprData::Fvar(n, _) => { return Err(CompileError::UnsupportedExpr { - desc: "free variable".into(), + desc: format!("free variable '{}'", n.pretty()), }); }, @@ -1354,6 +1556,7 @@ pub fn compile_expr( mut entries, n_canonical, n_collapsed, + orig_head_collapsed, } => { // Pop collapsed arg results and their arena roots let mut collapsed_exprs = Vec::with_capacity(n_collapsed); @@ -1414,6 +1617,11 @@ pub fn compile_expr( // short-circuits anyway — non-identity is the case where surgery // actually fires, and only `canon_idx` gives the right root // there. + // + // When `orig_head_collapsed`, the LAST collapsed slot is the + // original head expression — it has no source-order entry, so the + // sequential fill below never reaches it; it's referenced by the + // node's `orig_head` field instead. let mut collapsed_idx = 0usize; for entry in &mut entries { match entry { @@ -1427,12 +1635,21 @@ pub fn compile_expr( }, } } + let orig_head = if orig_head_collapsed && n_collapsed > 0 { + Some(( + (sharing_base + n_collapsed - 1) as u64, + collapsed_roots[n_collapsed - 1], + )) + } else { + None + }; // Allocate CallSite metadata node in the arena let call_site_root = cache.arena.alloc(ExprMetaData::CallSite { name: name_addr, entries, canon_meta, + orig_head, }); // Build canonical Ixon App spine: foldl App head canonical_args @@ -3854,21 +4071,28 @@ fn compile_mutual( aux_layout_stored.as_ref(), )?; for (name, plan) in plans { - if let Some(brecon_name) = surgery::rec_name_to_brecon_name(&name) - && lean_env.get(&brecon_name).is_some() - { - stt.brec_on_call_site_plans.insert( - brecon_name, - surgery::BRecOnCallSitePlan::from_rec_plan(&plan), - ); - } - if let Some(below_name) = surgery::rec_name_to_below_name(&name) - && lean_env.get(&below_name).is_some() - { - stt.below_call_site_plans.insert( - below_name, - surgery::BRecOnCallSitePlan::from_rec_plan(&plan), - ); + // Head-rewritten (evaporated-aux) recursors get NO derived + // brecOn/below plans: their `.brecOn_N`/`.below_N` siblings have no + // canonical regeneration — they compile as surgered originals that + // KEEP the source telescope — so their callers must not be + // rewritten. + if plan.head_rewrite.is_none() { + if let Some(brecon_name) = surgery::rec_name_to_brecon_name(&name) + && lean_env.get(&brecon_name).is_some() + { + stt.brec_on_call_site_plans.insert( + brecon_name, + surgery::BRecOnCallSitePlan::from_rec_plan(&plan), + ); + } + if let Some(below_name) = surgery::rec_name_to_below_name(&name) + && lean_env.get(&below_name).is_some() + { + stt.below_call_site_plans.insert( + below_name, + surgery::BRecOnCallSitePlan::from_rec_plan(&plan), + ); + } } stt.call_site_plans.insert(name, plan); } @@ -4126,6 +4350,7 @@ mod tests { source_to_canon_motive: vec![0, 1, 3, 2], source_to_canon_minor: vec![0, 1, 3, 2], source_in_block: vec![true, true, true, true], + head_rewrite: None, }, ); @@ -4166,7 +4391,7 @@ mod tests { ); let root = *cache.arena_roots.last().expect("compiled expression root"); - let ExprMetaData::CallSite { name, entries, canon_meta } = + let ExprMetaData::CallSite { name, entries, canon_meta, orig_head: _ } = &cache.arena.nodes[root as usize] else { panic!("expected CallSite metadata at expression root"); diff --git a/crates/compile/src/compile/aux_gen.rs b/crates/compile/src/compile/aux_gen.rs index b6dec909..447a79fc 100644 --- a/crates/compile/src/compile/aux_gen.rs +++ b/crates/compile/src/compile/aux_gen.rs @@ -84,7 +84,7 @@ pub mod recursor; use std::sync::Arc; -use rustc_hash::FxHashMap; +use rustc_hash::{FxHashMap, FxHashSet}; use crate::compile::CompileState; use ix_common::env::{ @@ -498,7 +498,46 @@ pub fn generate_aux_patches( )? } } else { - // No nested types at all — standard path. + // Metadata/structural disagreement, or no nested at all — standard + // flat-block recursor generation. Two disagreement flavors still need + // the source→canonical aux permutation: + // + // * metadata-only: Lean's `num_nested` says nested but the + // SCC-filtered expansion finds nothing, because over-merge + // splitting moved every spec-param inductive of every aux out of + // this SCC (e.g. `mutual A | mk : List B → A; B | leaf end` + // splits into {A},{B} and `List B` stops being nested for {A}). + // The source walk still has aux positions; the perm is all + // `PERM_OUT_OF_SCC`, which drives call-site surgery drops and the + // evaporated-aux `.rec` aliases below. Falling back to + // `perm = None` would make surgery treat the evaporated auxes as + // identity-mapped canonical slots that don't exist. + // + // * structural-only: the detector finds auxes where Lean's metadata + // says zero (parameterized nested blocks); extra Lean aux names + // become address aliases keyed off the perm. + if structural_has_nested || metadata_has_nested { + let orig_to_canon_map: std::collections::HashMap = + sorted_classes + .iter() + .flat_map(|class| { + let rep = class[0].clone(); + class.iter().map(move |n| (n.clone(), rep.clone())) + }) + .collect(); + let n_canon = + expanded_probe.types.len().saturating_sub(expanded_probe.n_originals); + let perm = nested::compute_aux_perm( + &expanded_probe, + original_all, + lean_env, + stt, + &orig_to_canon_map, + )?; + captured_perm = Some(perm.clone()); + captured_n_canonical_aux = n_canon; + captured_n_source_aux = perm.len(); + } recursor::generate_canonical_recursors_with_overlay( sorted_classes, lean_env, @@ -878,6 +917,66 @@ pub fn generate_aux_patches( } } + // Evaporated aux recursor aliases. A source aux whose OWNER is in this + // SCC but whose spec-param inductives are not has no home in ANY split + // SCC (SCCs partition the block): the ctor walk that discovers it lives + // here, but the spec inductives that would make it a canonical aux + // member split away. The aux evaporates — the canonical block has no + // member for it, and dropping the irrelevant motives/minors from Lean's + // `.rec_{j+1}` leaves exactly the external inductive's own generic + // recursor (the isomorphic minimal declaration proves the same family + // without them). Alias the Lean-visible name to `.rec` so the claim + // resolves to the canonical constant instead of falling back to an + // original-form compile — the kernel rejects a standalone specialized + // recursor block, since it regenerates the generic signature from the + // external inductive's block. Call sites are rewritten onto the external + // telescope by the out-of-SCC surgery plan (`compute_call_site_plans`). + // + // The owner gate matters: an out-of-SCC entry whose owner is ALSO + // out-of-SCC is simply another SCC's aux (e.g. `List A` seen from C's + // block in an over-merged [A, B, C]) — that SCC compiles it as a normal + // canonical aux and registers the `_N` name; aliasing it here would + // conflict. + if let Some(perm) = captured_perm.as_ref() + && perm.contains(&nested::PERM_OUT_OF_SCC) + && let Some(first_orig_name) = original_all.first() + { + let in_scc: FxHashSet<&Name> = sorted_classes.iter().flatten().collect(); + let src_order = nested::source_aux_order_with_owner(original_all, lean_env)?; + for (source_j, &canonical_i) in perm.iter().enumerate() { + if canonical_i != nested::PERM_OUT_OF_SCC { + continue; + } + let Some((owner, ext_head, _)) = src_order.get(source_j) else { + continue; + }; + if !in_scc.contains(owner) { + continue; + } + let source_name = + Name::str(first_orig_name.clone(), format!("rec_{}", source_j + 1)); + let target_name = Name::str(ext_head.clone(), "rec".to_string()); + // Target guard mirrors the head-rewrite plan registration in + // `surgery::compute_call_site_plans` — alias and call-site rewrite + // must fire together or not at all, or callers and claim disagree. + // Multi-motive external targets (mutual/nested external families) + // are outside the supported rewrite domain; skipping leaves the + // original compile, which kernel-check reports per constant. + let target_ok = matches!( + lean_env.get(&target_name), + Some(ix_common::env::ConstantInfo::RecInfo(r)) + if crate::compile::nat_conv::nat_to_usize(&r.num_motives) == 1 + ); + if patches.contains_key(&source_name) + || lean_env.get(&source_name).is_none() + || !target_ok + { + continue; + } + aliases.insert(source_name, target_name); + } + } + Ok(AuxPatchesOutput { patches, aliases, diff --git a/crates/compile/src/compile/aux_gen/expr_utils.rs b/crates/compile/src/compile/aux_gen/expr_utils.rs index 7bfdc26a..ec024ee5 100644 --- a/crates/compile/src/compile/aux_gen/expr_utils.rs +++ b/crates/compile/src/compile/aux_gen/expr_utils.rs @@ -659,7 +659,12 @@ pub(super) fn instantiate1_at( /// Matches Lean C++ `instantiate_rev(e, n, subst)`. At binder depth `d`, /// BVar(d + i) for i < n becomes `shift_vars(args[i], d, 0)`, and /// BVar(d + i) for i >= n becomes BVar(d + i - n). -pub(super) fn instantiate_rev(body: &LeanExpr, args: &[LeanExpr]) -> LeanExpr { +/// +/// Unlike [`instantiate1`], the substituted argument's loose BVars are +/// LIFTED by the binder depth at each site — required whenever the +/// argument may reference the caller's telescope (e.g. call-site surgery +/// on an application under binders, as in `.brecOn_N.go` bodies). +pub fn instantiate_rev(body: &LeanExpr, args: &[LeanExpr]) -> LeanExpr { if args.is_empty() { return body.clone(); } diff --git a/crates/compile/src/compile/surgery.rs b/crates/compile/src/compile/surgery.rs index 94a5029d..72d8489a 100644 --- a/crates/compile/src/compile/surgery.rs +++ b/crates/compile/src/compile/surgery.rs @@ -33,7 +33,7 @@ use ixon::expr::Expr as IxonExpr; use super::{ aux_gen::expr_utils::{ LocalDecl, consume_type_annotations, decompose_apps, fresh_fvar, - instantiate1, mk_lambda, subst_levels, + instantiate1, instantiate_rev, mk_lambda, subst_levels, }, nat_conv::nat_to_usize, }; @@ -81,6 +81,28 @@ pub struct CallSitePlan { /// "canonical recursor supplies an IH binder" from "the IH must be /// synthesized by a recursive call into another canonical block". pub source_in_block: Vec, + /// `Some` when the callee is an EVAPORATED aux recursor — a + /// `.rec_N` whose nested occurrence lost every spec-param inductive + /// to another SCC. Its claim is aliased to the external inductive's own + /// recursor (see the evaporated-aux alias pass in `aux_gen.rs`), so the + /// call spine must be rebuilt onto that telescope: + /// + /// source: params… motives… minors… indices… major (over-merged) + /// target: specs… motive minors′… indices… major (external rec) + /// + /// The spec args and extended level list are derived at the apply site + /// from the source recursor's type instantiated with the call-site args + /// (`derive_head_rewrite_app`). + pub head_rewrite: Option, +} + +/// Head-rewrite directive carried by [`CallSitePlan::head_rewrite`]. +#[derive(Clone, Debug)] +pub struct AuxHeadRewrite { + /// The external inductive's recursor (the alias target, e.g. `List.rec`). + pub target_rec: Name, + /// Source motive position of the evaporated aux (`n_user_motives + j`). + pub target_motive_pos: usize, } impl CallSitePlan { @@ -105,7 +127,8 @@ impl CallSitePlan { /// Whether this plan is an identity (no reordering, no collapse). pub fn is_identity(&self) -> bool { - self.motive_keep.iter().all(|&k| k) + self.head_rewrite.is_none() + && self.motive_keep.iter().all(|&k| k) && self.minor_keep.iter().all(|&k| k) && self.source_to_canon_motive.iter().enumerate().all(|(i, &c)| c == i) && self.source_to_canon_minor.iter().enumerate().all(|(i, &c)| c == i) @@ -314,9 +337,18 @@ pub fn compute_call_site_plans( let n_aux_minors = n_source_minors - n_user_minors; let aux_perm = aux_layout.map(|l| l.perm.as_slice()); + // When a perm is present, the canonical aux count comes from it — and an + // all-out-of-SCC perm means ZERO canonical auxes (every source aux + // evaporated with the SCC split), not the source count. Falling through + // to `n_source_aux_motives` there would resurrect phantom canonical + // slots and misalign every motive/minor mapping below. let aux_canonical_count = aux_perm - .and_then(|p| { - p.iter().copied().filter(|&c| c != PERM_OUT_OF_SCC).max().map(|m| m + 1) + .map(|p| { + p.iter() + .copied() + .filter(|&c| c != PERM_OUT_OF_SCC) + .max() + .map_or(0, |m| m + 1) }) .unwrap_or(n_source_aux_motives); @@ -593,9 +625,57 @@ pub fn compute_call_site_plans( source_to_canon_motive: source_to_canon_motive.clone(), source_to_canon_minor, source_in_block: source_in_block.clone(), + head_rewrite: None, } }; + // Build a plan for an EVAPORATED aux recursor `.rec_{aux_j+1}`: + // every spec-param inductive of source aux `aux_j` left this SCC, the + // claim is aliased to the external inductive's recursor, and call sites + // are rebuilt onto that telescope. Only the aux's own motive and its own + // minor band survive; the external recursor supplies the aux's IH + // binders (`source_in_block[x_pos] = true`), while IHs consumed from + // other dropped motives are synthesized by `adapt_split_minor`. + let build_out_of_scc_plan = + |x_pos: usize, aux_j: usize, target_rec: Name, n_indices: usize| { + let mut motive_keep = vec![false; n_source_motives]; + motive_keep[x_pos] = true; + let mut source_to_canon_motive = vec![0usize; n_source_motives]; + source_to_canon_motive[x_pos] = 0; + let counts: &[usize] = + aux_layout.map(|l| l.source_ctor_counts.as_slice()).unwrap_or(&[]); + let band_start: usize = + n_user_minors + counts.iter().take(aux_j).sum::(); + let band_len = counts.get(aux_j).copied().unwrap_or(0); + let mut minor_keep = vec![false; n_source_minors]; + let mut source_to_canon_minor = vec![0usize; n_source_minors]; + for k in 0..band_len { + if let Some(slot) = minor_keep.get_mut(band_start + k) { + *slot = true; + } + if let Some(slot) = source_to_canon_minor.get_mut(band_start + k) { + *slot = k; + } + } + let mut source_in_block = vec![false; n_source_motives]; + source_in_block[x_pos] = true; + CallSitePlan { + n_params, + n_source_motives, + n_source_minors, + n_indices, + motive_keep, + minor_keep, + source_to_canon_motive, + source_to_canon_minor, + source_in_block, + head_rewrite: Some(AuxHeadRewrite { + target_rec, + target_motive_pos: x_pos, + }), + } + }; + // Register plans for each user inductive's `X.rec` (x_pos ∈ [0, n_user)). for (x_pos, x_name) in original_all.iter().enumerate() { // Skip phantom X names: they belong to a different canonical block @@ -631,23 +711,71 @@ pub fn compute_call_site_plans( if n_source_motives > n_user_motives && let Some(head_name) = original_all.first() { + // (owner, external head) per source aux — only needed when some source + // aux is out-of-SCC, i.e. potentially evaporated. + let any_out = aux_perm + .is_some_and(|p| p.iter().any(|&c| c == PERM_OUT_OF_SCC)); + let src_owner_heads: Vec<(Name, Name)> = if any_out { + crate::compile::aux_gen::nested::source_aux_order_with_owner( + original_all, + lean_env, + )? + .into_iter() + .map(|(owner, head, _)| (owner, head)) + .collect() + } else { + Vec::new() + }; + for aux_idx in 0..(n_source_motives - n_user_motives) { - if aux_perm + let x_pos = n_user_motives + aux_idx; + let rec_name = + Name::str(head_name.clone(), format!("rec_{}", aux_idx + 1)); + if lean_env.get(&rec_name).is_none() { + continue; + } + let out_of_scc = aux_perm .and_then(|p| p.get(aux_idx).copied()) - .is_some_and(|canon_i| canon_i == PERM_OUT_OF_SCC) - { + .is_some_and(|canon_i| canon_i == PERM_OUT_OF_SCC); + if out_of_scc { + // Evaporated-aux head rewrite. Owner gate mirrors the alias pass + // in `aux_gen.rs`: an out-of-SCC aux whose OWNER is also + // out-of-SCC is another SCC's canonical aux (that SCC registers + // its plan); only the owner's SCC decides evaporation. The target + // guard also mirrors the alias pass — no alias means no rewrite, + // and vice versa, or callers and claim disagree. + let Some((owner, ext_head)) = src_owner_heads.get(aux_idx) else { + continue; + }; + if !name_to_class.contains_key(owner) { + continue; + } + let target_rec = Name::str(ext_head.clone(), "rec".to_string()); + let target_ok = matches!( + lean_env.get(&target_rec), + Some(LeanConstantInfo::RecInfo(r)) + if nat_to_usize(&r.num_motives) == 1 + ); + if !target_ok { + continue; + } + // Index count comes from the aux recursor itself (the external + // inductive's indices), not the block-wide default. + let rec_n_indices = match lean_env.get(&rec_name) { + Some(LeanConstantInfo::RecInfo(r)) => nat_to_usize(&r.num_indices), + _ => n_indices, + }; + plans.insert( + rec_name, + build_out_of_scc_plan(x_pos, aux_idx, target_rec, rec_n_indices), + ); continue; } - let x_pos = n_user_motives + aux_idx; let plan = build_plan(x_pos); if plan.is_identity() { continue; } - let rec_name = - Name::str(head_name.clone(), format!("rec_{}", aux_idx + 1)); - if lean_env.get(&rec_name).is_some() { - plans.insert(rec_name, plan); - } + plans.insert(rec_name, plan); } } @@ -727,8 +855,13 @@ pub fn adapt_split_minor( _ => return None, }; let original_all = rec.all.as_slice(); + // Nested-aux motive signatures: fields targeting an aux occurrence + // (`List B` rather than a user original) also carry IH binders in the + // source minor; they must be detected for the peel below to stay + // aligned, and synthesized/kept like user-target IHs. + let aux_sigs = aux_motive_sigs(rec, rec_levels, params, motives, lean_env); let (_parent_src, ctor) = - source_ctor_for_minor(src_minor_idx, rec, lean_env)?; + source_ctor_for_minor(src_minor_idx, rec, lean_env, &aux_sigs)?; let n_fields = nat_to_usize(&ctor.num_fields); let source_minor_ty = source_minor_type(rec, rec_levels, params, motives, minors, src_minor_idx)?; @@ -745,6 +878,7 @@ pub fn adapt_split_minor( lean_env, "split_xs", field_idx, + &aux_sigs, ) { rec_fields.push((field_idx, target)); } @@ -786,13 +920,33 @@ pub fn adapt_split_minor( } } - Some(mk_lambda(body, &wrapper_decls)) + let wrapper = mk_lambda(body, &wrapper_decls); + if std::env::var("IX_SPLIT_MINOR_DUMP").is_ok() { + let w = wrapper.pretty(); + if w.contains("fvar(") { + eprintln!( + "[adapt_split_minor.LEAK] rec={} minor_idx={} n_fields={} \ + rec_fields={:?}\n minor={}\n wrapper={}", + rec_name.pretty(), + src_minor_idx, + n_fields, + rec_fields + .iter() + .map(|(fi, t)| (*fi, t.source_pos)) + .collect::>(), + minor.pretty(), + w, + ); + } + } + Some(wrapper) } fn source_ctor_for_minor( src_minor_idx: usize, rec: &RecursorVal, lean_env: &LeanEnv, + aux_sigs: &[AuxMotiveSig], ) -> Option<(usize, ConstructorVal)> { let mut offset = 0usize; for (source_pos, ind_name) in rec.all.iter().enumerate() { @@ -812,9 +966,209 @@ fn source_ctor_for_minor( } offset += n_ctors; } + // Aux minor bands follow the user bands, one per source aux in source + // order. The ctor list is the external inductive's own (the aux is the + // external applied at spec args, so field counts match). + for sig in aux_sigs { + let Some(LeanConstantInfo::InductInfo(ind)) = lean_env.get(&sig.ext_name) + else { + return None; + }; + let n_ctors = ind.ctors.len(); + if src_minor_idx < offset + n_ctors { + let ctor_name = &ind.ctors[src_minor_idx - offset]; + let ctor = match lean_env.get(ctor_name)? { + LeanConstantInfo::CtorInfo(ctor) => ctor.clone(), + _ => return None, + }; + return Some((sig.source_pos, ctor)); + } + offset += n_ctors; + } None } +/// Signature of a nested-aux motive read off a source recursor's type: +/// motive `source_pos` targets `ext_name specs… idx…`. Spec args are +/// concrete (the recursor type is instantiated with call-site params +/// before extraction), so field types can be matched against them by hash. +struct AuxMotiveSig { + source_pos: usize, + ext_name: Name, + ext_n_params: usize, + specs: Vec, +} + +/// Extract [`AuxMotiveSig`]s for every aux motive position (`>= all.len()`) +/// of `rec`, by walking its type instantiated with the call site's levels, +/// params, and motives. +fn aux_motive_sigs( + rec: &RecursorVal, + rec_levels: &[Level], + params: &[LeanExpr], + motives: &[LeanExpr], + lean_env: &LeanEnv, +) -> Vec { + let n_user = rec.all.len(); + let n_motives = nat_to_usize(&rec.num_motives); + let mut out = Vec::new(); + if n_motives <= n_user { + return out; + } + let mut cur = subst_levels(&rec.cnst.typ, &rec.cnst.level_params, rec_levels); + for arg in params { + match cur.as_data() { + // Shift-aware substitution — args may reference the caller's + // telescope (see `source_minor_type`). + ExprData::ForallE(_, _, body, _, _) => { + cur = instantiate_rev(body, std::slice::from_ref(arg)); + }, + _ => return out, + } + } + for m_idx in 0..n_motives.min(motives.len()) { + let next = match cur.as_data() { + ExprData::ForallE(_, dom, body, _, _) => { + if m_idx >= n_user { + // dom = `∀ idx…, Ext specs… idx… → Sort _` — the major's type is + // the last peeled domain. + let mut d = consume_type_annotations(dom); + let mut last_dom: Option = None; + let mut i = 0usize; + while let ExprData::ForallE(_, dd, db, _, _) = d.as_data() { + last_dom = Some(consume_type_annotations(dd)); + let (_, fv) = fresh_fvar("aux_sig_idx", m_idx * 64 + i); + d = instantiate1(db, &fv); + i += 1; + } + if let Some(t) = last_dom { + let (head, t_args) = decompose_apps(&t); + if let ExprData::Const(ext_name, _, _) = head.as_data() + && let Some(LeanConstantInfo::InductInfo(ind)) = + lean_env.get(ext_name) + { + let ext_n_params = nat_to_usize(&ind.num_params); + if t_args.len() >= ext_n_params { + out.push(AuxMotiveSig { + source_pos: m_idx, + ext_name: ext_name.clone(), + ext_n_params, + specs: t_args.into_iter().take(ext_n_params).collect(), + }); + } + } + } + } + instantiate_rev(body, std::slice::from_ref(&motives[m_idx])) + }, + _ => return out, + }; + cur = next; + } + out +} + +/// Derive the pieces needed to rebuild a head-rewritten call site onto the +/// external recursor's telescope: the extended universe-level list and the +/// external inductive's parameter (spec) arguments. +/// +/// Both are read off the SOURCE aux recursor's type — the motive binder at +/// `hr.target_motive_pos` has domain `∀ idx…, Ext.{occ} specs… idx… → +/// Sort _` — instantiated with the call site's levels, params, and +/// preceding motives, so the result is expressed in caller terms. +pub fn derive_head_rewrite_app( + rec_name: &Name, + rec_levels: &[Level], + hr: &AuxHeadRewrite, + params: &[LeanExpr], + motives: &[LeanExpr], + lean_env: &LeanEnv, +) -> Result<(Vec, Vec), String> { + let Some(LeanConstantInfo::RecInfo(rec)) = lean_env.get(rec_name) else { + return Err(format!("'{}' is not a recursor", rec_name.pretty())); + }; + let sigs = aux_motive_sigs(rec, rec_levels, params, motives, lean_env); + let Some(sig) = + sigs.iter().find(|s| s.source_pos == hr.target_motive_pos) + else { + return Err(format!( + "no aux motive signature at position {}", + hr.target_motive_pos + )); + }; + if Name::str(sig.ext_name.clone(), "rec".to_string()) != hr.target_rec { + return Err(format!( + "aux motive targets '{}' but the plan's target is '{}'", + sig.ext_name.pretty(), + hr.target_rec.pretty() + )); + } + // Occurrence levels: re-extract the external const's level args from the + // motive's major type (aux_motive_sigs keeps only the value args). + let occ_levels = { + let mut cur = + subst_levels(&rec.cnst.typ, &rec.cnst.level_params, rec_levels); + for arg in params.iter().chain(motives.iter().take(hr.target_motive_pos)) + { + match cur.as_data() { + // Shift-aware substitution — args may reference the caller's + // telescope (see `source_minor_type`). + ExprData::ForallE(_, _, body, _, _) => { + cur = instantiate_rev(body, std::slice::from_ref(arg)); + }, + _ => return Err("recursor telescope too short".into()), + } + } + let ExprData::ForallE(_, dom, _, _, _) = cur.as_data() else { + return Err("missing target motive binder".into()); + }; + let mut d = consume_type_annotations(dom); + let mut last_dom: Option = None; + let mut i = 0usize; + while let ExprData::ForallE(_, dd, db, _, _) = d.as_data() { + last_dom = Some(consume_type_annotations(dd)); + let (_, fv) = fresh_fvar("hr_idx", i); + d = instantiate1(db, &fv); + i += 1; + } + let Some(t) = last_dom else { + return Err("motive domain has no major binder".into()); + }; + let (head, _) = decompose_apps(&t); + match head.as_data() { + ExprData::Const(_, lvls, _) => lvls.clone(), + _ => return Err("major type head is not a constant".into()), + } + }; + let Some(LeanConstantInfo::RecInfo(target)) = lean_env.get(&hr.target_rec) + else { + return Err(format!( + "target recursor '{}' missing from env", + hr.target_rec.pretty() + )); + }; + let needed = target.cnst.level_params.len(); + let target_levels: Vec = if needed == occ_levels.len() + 1 { + // Elimination level first (Lean's recursor level convention), then the + // external inductive's own levels from the occurrence. + let Some(elim) = rec_levels.first() else { + return Err("source recursor has no elimination level".into()); + }; + std::iter::once(elim.clone()).chain(occ_levels.iter().cloned()).collect() + } else if needed == occ_levels.len() { + occ_levels.clone() + } else { + return Err(format!( + "cannot map universe levels: target '{}' has {} level params, \ + occurrence supplies {}", + hr.target_rec.pretty(), + needed, + occ_levels.len() + )); + }; + Ok((target_levels, sig.specs.clone())) +} + fn source_minor_type( rec: &RecursorVal, rec_levels: &[Level], @@ -829,7 +1183,11 @@ fn source_minor_type( { match cur.as_data() { ExprData::ForallE(_, _, body, _, _) => { - cur = instantiate1(body, arg); + // `instantiate_rev`, not `instantiate1`: call-site args may carry + // loose BVars into the caller's telescope (rec applications under + // binders, e.g. `.brecOn_N.go` bodies) and must be lifted when + // substituted under the type's remaining binders. + cur = instantiate_rev(body, std::slice::from_ref(arg)); }, _ => return None, } @@ -883,6 +1241,7 @@ fn find_source_rec_target( lean_env: &LeanEnv, prefix: &str, field_idx: usize, + aux_sigs: &[AuxMotiveSig], ) -> Option { let mut cur = consume_type_annotations(dom); let mut xs_decls = Vec::new(); @@ -906,25 +1265,45 @@ fn find_source_rec_target( let ExprData::Const(target_name, _, _) = head.as_data() else { return None; }; - let source_pos = original_all.iter().position(|n| n == target_name)?; - let target_n_params = match lean_env.get(target_name)? { - LeanConstantInfo::InductInfo(ind) => nat_to_usize(&ind.num_params), - _ => return None, - }; - if args.len() < target_n_params || params.len() < target_n_params { - return None; - } - if !args[..target_n_params] - .iter() - .zip(params.iter()) - .all(|(arg, param)| arg.get_hash() == param.get_hash()) + if let Some(source_pos) = + original_all.iter().position(|n| n == target_name) { - return None; + let target_n_params = match lean_env.get(target_name)? { + LeanConstantInfo::InductInfo(ind) => nat_to_usize(&ind.num_params), + _ => return None, + }; + if args.len() < target_n_params || params.len() < target_n_params { + return None; + } + if !args[..target_n_params] + .iter() + .zip(params.iter()) + .all(|(arg, param)| arg.get_hash() == param.get_hash()) + { + return None; + } + return Some(SourceRecTarget { + source_pos, + idx_args: args.into_iter().skip(target_n_params).collect(), + xs_decls, + xs_fvars, + }); } - + // Nested-aux target: the field's type is an external-inductive + // application matching one of the recursor's aux motive signatures + // (`List B` targeting motive `n_user + j`). Spec args are compared by + // hash — both sides are instantiated with the same call-site params. + let matched = aux_sigs.iter().find(|sig| { + *target_name == sig.ext_name + && args.len() >= sig.ext_n_params + && args[..sig.ext_n_params] + .iter() + .zip(sig.specs.iter()) + .all(|(arg, spec)| arg.get_hash() == spec.get_hash()) + })?; Some(SourceRecTarget { - source_pos, - idx_args: args.into_iter().skip(target_n_params).collect(), + source_pos: matched.source_pos, + idx_args: args.into_iter().skip(matched.ext_n_params).collect(), xs_decls, xs_fvars, }) @@ -939,8 +1318,17 @@ fn synthesize_external_ih( motives: &[LeanExpr], minors: &[LeanExpr], ) -> LeanExpr { - let target_name = &original_all[target.source_pos]; - let target_rec_name = Name::str(target_name.clone(), "rec".to_string()); + // User targets eliminate with the target's own source recursor; aux + // targets (source_pos >= all.len()) with the source aux recursor + // `.rec_{j+1}`. Either way the full source telescope is passed + // verbatim — the inner call then goes through its own call-site surgery + // (plan lookup by head name), which canonicalizes it for its SCC. + let target_rec_name = if target.source_pos < original_all.len() { + Name::str(original_all[target.source_pos].clone(), "rec".to_string()) + } else { + let aux_j = target.source_pos - original_all.len(); + Name::str(original_all[0].clone(), format!("rec_{}", aux_j + 1)) + }; let mut ih = LeanExpr::cnst(target_rec_name, rec_levels.to_vec()); for arg in params { @@ -1164,10 +1552,34 @@ mod tests { source_to_canon_motive: vec![0, 1], source_to_canon_minor: vec![0, 1], source_in_block: vec![true, true], + head_rewrite: None, }; assert!(plan.is_identity()); } + #[test] + fn test_head_rewrite_plan_never_identity() { + // An otherwise-identity plan with a head rewrite must still fire: + // the spine has to be rebuilt onto the external recursor's telescope + // even when no motive/minor is dropped or permuted. + let plan = CallSitePlan { + n_params: 0, + n_source_motives: 1, + n_source_minors: 1, + n_indices: 0, + motive_keep: vec![true], + minor_keep: vec![true], + source_to_canon_motive: vec![0], + source_to_canon_minor: vec![0], + source_in_block: vec![true], + head_rewrite: Some(AuxHeadRewrite { + target_rec: nn("List", "rec"), + target_motive_pos: 0, + }), + }; + assert!(!plan.is_identity()); + } + #[test] fn test_non_identity_plan_collapsed() { let plan = CallSitePlan { @@ -1180,6 +1592,7 @@ mod tests { source_to_canon_motive: vec![0, 1, 0], source_to_canon_minor: vec![0, 1, 0], source_in_block: vec![true, true, true], + head_rewrite: None, }; assert!(!plan.is_identity()); } @@ -1196,6 +1609,7 @@ mod tests { source_to_canon_motive: vec![2, 0, 1], // permuted source_to_canon_minor: vec![2, 0, 1], source_in_block: vec![true, true, true], + head_rewrite: None, }; assert!(!plan.is_identity()); } diff --git a/crates/compile/src/decompile.rs b/crates/compile/src/decompile.rs index e0165c54..a720ec23 100644 --- a/crates/compile/src/decompile.rs +++ b/crates/compile/src/decompile.rs @@ -786,7 +786,10 @@ pub fn decompile_expr( }, // CallSite: surgered call-site — reconstruct source-order telescope - (ExprMetaData::CallSite { name, entries, canon_meta: _ }, _) => { + ( + ExprMetaData::CallSite { name, entries, canon_meta: _, orig_head }, + _, + ) => { // Collect the canonical Ixon App telescope let (head_ixon, canonical_args) = collect_ixon_telescope_expanding_shares(&e, cache)?; @@ -812,30 +815,53 @@ pub fn decompile_expr( }); } - // Decompile head: resolve name from CallSite. This must succeed — - // a CallSite metadata node without a resolvable head indicates - // compiler/decompiler corruption, not malformed user input. - let head_name = decompile_name(name, stt).map_err(|_| { - DecompileError::BadConstantFormat { - msg: format!( - "CallSite in '{}': head name address does not resolve", - cache.current_const - ), - } - })?; - // Extract univ args from head - let levels = match head_ixon.as_ref() { - Expr::Ref(_, univ_indices) | Expr::Rec(_, univ_indices) => { - decompile_univ_indices(univ_indices, lvl_names, cache)? - }, - _ => vec![], + // Head restore. A head-rewritten call site (evaporated-aux + // recursor rebuilt onto the external recursor's telescope) + // stores the canonical head with the TARGET's extended level + // list; the ORIGINAL head expression (source name + source + // level args) lives in meta_sharing, pointed at by + // `orig_head` — decompile that instead. Otherwise rebuild the + // head from the CallSite name + the stored head's levels. + let orig_head_frame = if let Some((sharing_idx, meta)) = orig_head + { + let head_share = cache + .meta_sharing + .get(*sharing_idx as usize) + .ok_or_else(|| DecompileError::InvalidShareIndex { + idx: *sharing_idx, + max: cache.meta_sharing.len(), + constant: cache.current_const.clone(), + })? + .clone(); + Some(Frame::Decompile(head_share, *meta)) + } else { + // Decompile head: resolve name from CallSite. This must + // succeed — a CallSite metadata node without a resolvable + // head indicates compiler/decompiler corruption, not + // malformed user input. + let head_name = decompile_name(name, stt).map_err(|_| { + DecompileError::BadConstantFormat { + msg: format!( + "CallSite in '{}': head name address does not resolve", + cache.current_const + ), + } + })?; + // Extract univ args from head + let levels = match head_ixon.as_ref() { + Expr::Ref(_, univ_indices) | Expr::Rec(_, univ_indices) => { + decompile_univ_indices(univ_indices, lvl_names, cache)? + }, + _ => vec![], + }; + // Push the bare head (Mdata is applied by BuildTelescope to + // the entire spine, not just the head — wrapping here would + // produce `App(App(mdata(head), a), b)` instead of the + // correct `mdata(App(App(head, a), b))` and break roundtrip + // hash equality). + results.push(LeanExpr::cnst(head_name, levels)); + None }; - // Push the bare head (Mdata is applied by BuildTelescope to - // the entire spine, not just the head — wrapping here would - // produce `App(App(mdata(head), a), b)` instead of the - // correct `mdata(App(App(head, a), b))` and break roundtrip - // hash equality). - results.push(LeanExpr::cnst(head_name, levels)); // Push BuildTelescope to assemble source-order App spine. // `mdata_layers` travels with the telescope so the final @@ -896,6 +922,13 @@ pub fn decompile_expr( }, } } + // Head-rewritten sites: the original-head frame is pushed + // LAST so it executes FIRST — its result must sit beneath the + // args on the results stack when BuildTelescope assembles the + // spine (matching the `results.push(head)` of the plain path). + if let Some(frame) = orig_head_frame { + stack.push(frame); + } // The outer `Frame::CacheResult` pushed at the top of // `Frame::Decompile` will fire after BuildTelescope finishes, // caching the fully-assembled spine. @@ -2404,6 +2437,55 @@ fn ixon_content_address(constant: &Constant) -> Address { /// used only for diagnostic hash comparisons. When `None` (production/no-debug /// path), hash comparisons against originals are skipped — the roundtrip still /// produces correct constants via metadata restoration. +/// Debug summary of a compiled Ixon class representative: the HASHED +/// scalar fields plus per-component serialization hashes. Pretty-printed +/// types can be identical while these differ (`hints`/`all` are metadata, +/// not hashed — they can never cause an address mismatch). Used by the +/// `IX_ROUNDTRIP_DEBUG` mismatch dump in `roundtrip_block`. +fn ixon_mut_const_summary(label: &str, class_idx: usize, mc: &MutConst) -> String { + let ehash = |e: &Arc| -> String { + let mut b = Vec::new(); + ixon::serialize::put_expr(e, &mut b); + Address::hash(&b).hex()[..12].to_string() + }; + match mc { + MutConst::Recr(r) => format!( + " -- {label} class[{class_idx}] Recr: k={} unsafe={} lvls={} \ + params={} indices={} motives={} minors={} rule_fields={:?} \ + typ#={} rule_rhs#={:?}", + r.k, + r.is_unsafe, + r.lvls, + r.params, + r.indices, + r.motives, + r.minors, + r.rules.iter().map(|ru| ru.fields).collect::>(), + ehash(&r.typ), + r.rules.iter().map(|ru| ehash(&ru.rhs)).collect::>(), + ), + MutConst::Defn(d) => format!( + " -- {label} class[{class_idx}] Defn: kind={:?} safety={:?} \ + lvls={} typ#={} value#={}", + d.kind, + d.safety, + d.lvls, + ehash(&d.typ), + ehash(&d.value), + ), + MutConst::Indc(i) => format!( + " -- {label} class[{class_idx}] Indc: unsafe={} lvls={} \ + params={} indices={} ctors={} typ#={}", + i.is_unsafe, + i.lvls, + i.params, + i.indices, + i.ctors.len(), + ehash(&i.typ), + ), + } +} + fn roundtrip_block( consts: &[LeanMutConst], generated_consts: &FxHashMap, @@ -2412,8 +2494,9 @@ fn roundtrip_block( dstt: &DecompileState, ) -> Result, DecompileError> { use crate::compile::{ - BlockCache as CompileBlockCache, compile_definition, compile_inductive, - compile_mutual_block, compile_recursor, sort_consts, + BlockCache as CompileBlockCache, collect_mut_const_exprs, + compile_definition, compile_inductive, compile_mutual_block, + compile_recursor, preseed_expr_tables, sort_consts, }; use crate::mutual::ctx_to_all; @@ -2435,6 +2518,33 @@ fn roundtrip_block( })?; let mut_ctx = LeanMutConst::ctx(&sorted_classes); + // Mirror the production compile paths (`compile_single_def`, the + // singleton-RecInfo arm of `compile_const_inner`, `compile_mutual`): + // preseed the cache's ref/univ tables from ALL block exprs before + // compiling. The preseed inserts refs and univs in SORTED order and + // the serialized constant embeds those tables — without it the tables + // fill in traversal order, permuting every `Ref(i)`/univ index: a + // byte-different but semantically identical constant (decode resolves + // through the embedded table, so Phase B and 7b still round-trip + // exactly). This silently failed the Phase-A address comparison + // against `Named.original.0` for 1529 of 1545 aux constants. + // The preseed sorts + dedups, so collection order is irrelevant. + { + let mut exprs: Vec<(&LeanExpr, &[Name])> = Vec::new(); + for class in &sorted_classes { + for cnst in class { + collect_mut_const_exprs(cnst, &mut exprs); + } + } + preseed_expr_tables(&exprs, &mut_ctx, &mut cache, stt, "roundtrip_block") + .map_err(|e| DecompileError::BadConstantFormat { + msg: format!( + "roundtrip preseed {}: {e}", + consts[0].name().pretty() + ), + })?; + } + // Map from name → (class_idx, MutConst kind) for projection construction. let mut name_to_class: FxHashMap = FxHashMap::default(); let mut all_metas: FxHashMap = FxHashMap::default(); @@ -2506,6 +2616,21 @@ fn roundtrip_block( let block_univs: Vec> = cache.univs.iter().cloned().collect(); let name_str = consts[0].name().pretty(); + // Precompute (debug-gated) component-level summaries of the compiled + // class representatives BEFORE `ixon_mutuals` is moved into the block + // compile below. Pretty-printed types can be identical while HASHED + // scalar fields (recursor params/indices/motives/minors/k, def + // kind/safety, lvls) or sub-expressions differ (`hints`/`all` are + // metadata, not hashed — they can never cause an address mismatch). + let debug_class_summaries: Option> = + std::env::var_os("IX_ROUNDTRIP_DEBUG").map(|_| { + ixon_mutuals + .iter() + .enumerate() + .map(|(class_idx, mc)| ixon_mut_const_summary("regen", class_idx, mc)) + .collect() + }); + let (block_constant, block_addr) = if singleton && ixon_mutuals.len() == 1 { // Singleton: compile as bare constant (no Muts wrapper). let result = match &ixon_mutuals[0] { @@ -2581,7 +2706,6 @@ fn roundtrip_block( if let Some(orig) = orig_addr && block_addr != orig { - let first_is_aux_gen = is_aux_gen_suffix(&first_name); if std::env::var_os("IX_ROUNDTRIP_DEBUG").is_some() { // Full dump so we can compare what aux_gen regenerated vs // Lean's source for the failing constant. Set @@ -2625,17 +2749,163 @@ fn roundtrip_block( } } } + // Component-level dump (precomputed above, before the block + // compile consumed `ixon_mutuals`) plus the Lean originals' + // counts, so the diverging hashed component is identifiable. + if let Some(summaries) = &debug_class_summaries { + for s in summaries { + eprintln!("{s}"); + } + } + for cnst in consts { + let nm = cnst.name(); + if let Some(orig_env) = orig_env + && let Some(ci) = orig_env.get(&nm) + { + match ci { + LeanConstantInfo::RecInfo(rv) => eprintln!( + " -- lean {} RecInfo: k={} unsafe={} lvls={} params={} \ + indices={} motives={} minors={} rule_fields={:?}", + nm.pretty(), + rv.k, + rv.is_unsafe, + rv.cnst.level_params.len(), + rv.num_params, + rv.num_indices, + rv.num_motives, + rv.num_minors, + rv.rules + .iter() + .map(|ru| ru.n_fields.clone()) + .collect::>(), + ), + LeanConstantInfo::DefnInfo(dv) => eprintln!( + " -- lean {} DefnInfo: safety={:?} lvls={}", + nm.pretty(), + dv.safety, + dv.cnst.level_params.len(), + ), + LeanConstantInfo::ThmInfo(tv) => eprintln!( + " -- lean {} ThmInfo: lvls={}", + nm.pretty(), + tv.cnst.level_params.len(), + ), + _ => {}, + } + } + } + // Probe: recompile the LEAN ORIGINAL through the identical + // singleton path in a fresh cache, using the same production + // conversions (`Def::mk_defn`/`mk_theo`/`mk_opaq`, `Recr(rv)`). + // Compile is deterministic, so: + // addr == orig ⇒ the roundtrip context is faithful and the + // REGEN input must differ at byte level — diff this probe + // summary against the regen summary above. + // addr != orig ⇒ `Named.original.0` is not reproducible from + // the constant alone: the original-track compile context + // (cache/ref-table/surgery state) differed, and the + // divergence is contextual, not a regen defect. + if singleton && let Some(oenv) = orig_env { + let nm = consts[0].name(); + let omc: Option = match oenv.get(&nm) { + Some(LeanConstantInfo::RecInfo(rv)) => { + Some(LeanMutConst::Recr(rv.clone())) + }, + Some(LeanConstantInfo::DefnInfo(dv)) => { + Some(LeanMutConst::Defn(Def::mk_defn(dv))) + }, + Some(LeanConstantInfo::ThmInfo(tv)) => { + Some(LeanMutConst::Defn(Def::mk_theo(tv))) + }, + Some(LeanConstantInfo::OpaqueInfo(ov)) => { + Some(LeanMutConst::Defn(Def::mk_opaq(ov))) + }, + _ => None, + }; + if let Some(omc) = omc { + let mut pcache = CompileBlockCache::default(); + let mut pexprs: Vec<(&LeanExpr, &[Name])> = Vec::new(); + collect_mut_const_exprs(&omc, &mut pexprs); + let preseeded = preseed_expr_tables( + &pexprs, + &mut_ctx, + &mut pcache, + stt, + "roundtrip_probe", + ); + let compiled = preseeded.and_then(|()| match &omc { + LeanMutConst::Defn(d) => { + compile_definition(d, &mut_ctx, &mut pcache, stt) + .map(|(data, _)| MutConst::Defn(data)) + }, + LeanMutConst::Recr(r) => { + compile_recursor(r, &mut_ctx, &mut pcache, stt) + .map(|(data, _)| MutConst::Recr(data)) + }, + LeanMutConst::Indc(_) => unreachable!("probe is Defn/Recr only"), + }); + match compiled { + Ok(data) => { + let prefs: Vec
= + pcache.refs.iter().cloned().collect(); + let punivs: Vec> = + pcache.univs.iter().cloned().collect(); + let result = match &data { + MutConst::Defn(def) => { + crate::compile::apply_sharing_to_definition_with_stats( + def.clone(), + prefs, + punivs, + Some(&name_str), + ) + }, + MutConst::Recr(rec) => { + crate::compile::apply_sharing_to_recursor_with_stats( + rec.clone(), + prefs, + punivs, + ) + }, + MutConst::Indc(_) => unreachable!(), + }; + let mut pbytes = Vec::new(); + result.constant.put(&mut pbytes); + let paddr = Address::hash(&pbytes); + eprintln!( + " -- probe original-form recompile: addr={:.12} vs orig {:.12} => {}", + paddr.hex(), + orig.hex(), + if paddr == orig { + "REPRODUCED (context faithful; regen input differs)" + } else { + "NOT REPRODUCED (orig addr is context-dependent)" + }, + ); + eprintln!("{}", ixon_mut_const_summary("probe", 0, &data)); + }, + Err(e) => { + eprintln!(" -- probe original-form recompile FAILED: {e}"); + }, + } + } + } } - if !first_is_aux_gen { - return Err(DecompileError::BadConstantFormat { - msg: format!( - "roundtrip recompile hash mismatch for '{}': recompiled={:.12} original={:.12}", - first_name.pretty(), - block_addr.hex(), - orig.hex(), - ), - }); - } + // Hard invariant (no aux exemption): the regenerated block must + // recompile to exactly `Named.original.0`. Since the preseed fix + // (see `preseed_expr_tables` above) this holds for every aux + // constant in the corpus — full-env rust-compile Phases 2+6 and + // validate-aux all report zero mismatches — so any mismatch here + // is a regression, not an expected divergence. Callers record it + // in `aux_gen_errors` (recovery keeps the Lean-facing env + // populated for diagnosis, but the error is never silent). + return Err(DecompileError::BadConstantFormat { + msg: format!( + "roundtrip recompile hash mismatch for '{}': recompiled={:.12} original={:.12}", + first_name.pretty(), + block_addr.hex(), + orig.hex(), + ), + }); } } @@ -2944,7 +3214,15 @@ fn roundtrip_block( } }, Err(e) => { - eprintln!("[roundtrip] decompile failed for {}: {e}", name.pretty()); + // Callers recover shape-divergent aux members from the original + // pair (`recover_aux_from_original`), so this is expected for + // over-merged/collapsed blocks — keep the trace debug-gated. + if std::env::var_os("IX_ROUNDTRIP_DEBUG").is_some() { + eprintln!( + "[roundtrip] decompile failed for {}: {e}", + name.pretty() + ); + } return Err(e); }, } @@ -3512,6 +3790,60 @@ fn install_decompile_call_site_plans( Ok(()) } +/// Source-faithful recovery for an aux constant whose canonical +/// regeneration diverges from Lean's original declaration (over-merge +/// splits, alpha collapse, evaporated auxes). `roundtrip_block` pairs the +/// REGENERATED bytes with the ORIGINAL metadata — aligned only when regen +/// and original are structurally congruent; for shape-divergent blocks the +/// pairing misaligns ("missing Ref metadata"). The original compile track +/// (`Named.original`) stores an address+metadata pair that is aligned by +/// construction, and decompiling it reproduces Lean's exact constant — +/// which is the whole point of the sidecar (see `Named::original` docs). +/// The canonical regeneration remains the claim; this only restores the +/// Lean-facing view in `dstt.env`. +/// +/// Returns `true` when the original pair existed and decompiled cleanly. +fn recover_aux_from_original( + name: &Name, + stt: &CompileState, + dstt: &DecompileState, +) -> bool { + let original = match stt.env.named.get(name) { + Some(named) => named.original.clone(), + None => None, + }; + let Some((orig_addr, orig_meta)) = original else { + return false; + }; + let had_entry = dstt.env.contains_key(name); + let synthetic = + Named { addr: orig_addr, meta: orig_meta, original: None }; + if decompile_named_const(name, &synthetic, stt, dstt).is_err() { + return false; + } + // `decompile_named_const` silently no-ops when the original's constant + // bytes are absent from the env (its missing-address arm returns Ok). + // Recovery must not claim success unless the entry actually landed — + // otherwise the caller skips its regen fallback and the constant goes + // missing from the decompiled env. + if !had_entry && !dstt.env.contains_key(name) { + return false; + } + // Debug-track validation: when the source env is available, the + // recovered constant must be Lean's original bit-for-bit. A mismatch + // means the original pair itself is corrupt — surface the roundtrip + // error rather than silently accepting the recovery. + if let Some(lean_env) = stt.lean_env.as_ref() + && let Some(orig_ci) = lean_env.get(name) + { + return matches!( + dstt.env.get(name), + Some(recovered) if recovered.get_hash() == orig_ci.get_hash() + ); + } + true +} + fn decompile_block_aux_gen( all_names: &[Name], aux_members: &[(AuxKind, Name)], @@ -3676,6 +4008,7 @@ fn decompile_block_aux_gen( dstt.env.insert(n.clone(), LeanConstantInfo::RecInfo(rv.clone())); } } + aux_gen_errors.push((all_names[0].clone(), e)); }, } } @@ -3770,11 +4103,27 @@ fn decompile_block_aux_gen( dstt.env.insert(n, ci); } }, - Ok(_) | Err(_) => { - if let Some(ci) = generated_consts.get(&aux_def.name) { + Ok(_) => { + // Empty roundtrip result: prefer the source-faithful original + // pair; fall back to the regenerated form otherwise. + if !recover_aux_from_original(&aux_def.name, stt, dstt) + && let Some(ci) = generated_consts.get(&aux_def.name) + { dstt.env.insert(aux_def.name.clone(), ci.clone()); } }, + Err(e) => { + // Recovery keeps the Lean-facing env populated for diagnosis, + // but the failure is always recorded — post-preseed, the + // roundtrip is byte-exact corpus-wide, so any error here is + // a regression. + if !recover_aux_from_original(&aux_def.name, stt, dstt) + && let Some(ci) = generated_consts.get(&aux_def.name) + { + dstt.env.insert(aux_def.name.clone(), ci.clone()); + } + aux_gen_errors.push((aux_def.name.clone(), e)); + }, } } } @@ -3848,10 +4197,26 @@ fn decompile_block_aux_gen( dstt.env.insert(n, ci); } }, - Ok(_) | Err(_) => { - if let Some(ci) = generated_consts.get(&aux_def.name) { + Ok(_) => { + // Empty roundtrip result: prefer the source-faithful original + // pair; fall back to the regenerated form otherwise. + if !recover_aux_from_original(&aux_def.name, stt, dstt) + && let Some(ci) = generated_consts.get(&aux_def.name) + { + dstt.env.insert(aux_def.name.clone(), ci.clone()); + } + }, + Err(e) => { + // Recovery keeps the Lean-facing env populated for diagnosis, + // but the failure is always recorded — post-preseed, the + // roundtrip is byte-exact corpus-wide, so any error here is + // a regression. + if !recover_aux_from_original(&aux_def.name, stt, dstt) + && let Some(ci) = generated_consts.get(&aux_def.name) + { dstt.env.insert(aux_def.name.clone(), ci.clone()); } + aux_gen_errors.push((aux_def.name.clone(), e)); }, } } @@ -3966,6 +4331,7 @@ fn decompile_block_aux_gen( if let BelowConstant::Indc(i) = bc && below_members.contains(&&i.name) { + let _ = recover_aux_from_original(&i.name, stt, dstt); aux_gen_errors.push((i.name.clone(), e.clone())); } } @@ -3987,6 +4353,18 @@ fn decompile_block_aux_gen( let BelowConstant::Def(d) = bc else { continue; }; + // Only roundtrip regen-track members: `aux_members` lists exactly + // the `Named.original`-bearing names Pass 1 skipped (see the + // `blocks` construction in `decompile_env`), mirroring the + // `brecon_members` filter below. Source-form regeneration also + // emits evaporated `below_N` (over-merge splits, §6.5) — those + // compiled as surgered originals with full storage, so Pass 1 + // already decompiled them faithfully, and recompiling them here + // would re-run call-site surgery, whose head-rewrite derivation + // requires `stt.lean_env` (absent on a deserialized state). + if !below_members.contains(&&d.name) { + continue; + } // DEBUG: report Lean's `.all` and the Ixon addr/kind stored at // `Named.original.0`, so we can tell whether Lean emitted this // below as a bare def or whether compile_const_no_aux grouped @@ -4050,6 +4428,11 @@ fn decompile_block_aux_gen( } }, Err(e) => { + // Recovery keeps the Lean-facing env populated for diagnosis, + // but the failure is always recorded — post-preseed, the + // roundtrip is byte-exact corpus-wide, so any error here is a + // regression. + let _ = recover_aux_from_original(&d.name, stt, dstt); aux_gen_errors.push((d.name.clone(), e)); }, } @@ -4115,12 +4498,15 @@ fn decompile_block_aux_gen( dstt.env.insert(n, ci); } }, - Err(_) => { + Err(e) => { for (n, rv) in &below_recs { if below_rec_members.contains(&n) { - dstt - .env - .insert(n.clone(), LeanConstantInfo::RecInfo(rv.clone())); + if !recover_aux_from_original(n, stt, dstt) { + dstt + .env + .insert(n.clone(), LeanConstantInfo::RecInfo(rv.clone())); + } + aux_gen_errors.push((n.clone(), e.clone())); } } }, @@ -4215,15 +4601,25 @@ fn decompile_block_aux_gen( dstt.env.insert(n, ci); } }, - Ok(_) | Err(_) => { - // Fallback when the roundtrip_block compile step fails: - // still surface a best-effort LeanConstantInfo so the - // decompiled env is populated. `brecon_def_to_lean` applies - // the same kind/safety/hints matrix that the compile path - // used, so the kind recorded here mirrors what Lean's - // original has (even if the recompile couldn't prove byte - // equivalence). - dstt.env.insert(d.name.clone(), brecon_def_to_lean(d)); + Ok(_) => { + // Empty roundtrip result: prefer the source-faithful + // original pair; otherwise surface a best-effort + // LeanConstantInfo so the decompiled env is populated. + // `brecon_def_to_lean` applies the same kind/safety/hints + // matrix that the compile path used. + if !recover_aux_from_original(&d.name, stt, dstt) { + dstt.env.insert(d.name.clone(), brecon_def_to_lean(d)); + } + }, + Err(e) => { + // Recovery keeps the Lean-facing env populated for + // diagnosis, but the failure is always recorded — + // post-preseed, the roundtrip is byte-exact corpus-wide, + // so any error here is a regression. + if !recover_aux_from_original(&d.name, stt, dstt) { + dstt.env.insert(d.name.clone(), brecon_def_to_lean(d)); + } + aux_gen_errors.push((d.name.clone(), e)); }, } } @@ -4786,6 +5182,7 @@ mod tests { name: head_addr.clone(), entries, canon_meta: vec![leaf0, leaf1, leaf2], + orig_head: None, }); // Canonical Ixon App spine: head applied to canonical-order args @@ -4879,6 +5276,7 @@ mod tests { name: head_addr.clone(), entries, canon_meta: vec![major_leaf], + orig_head: None, }); // Canonical Ixon spine: App(head, major). Major is a distinguishable @@ -5001,6 +5399,7 @@ mod tests { CallSiteEntry::Kept { canon_idx: 0, meta: major_leaf }, ], canon_meta: vec![major_leaf], + orig_head: None, }); // Ixon expressions: type is Sort 0, value is the canonical App spine diff --git a/crates/ffi/src/lean_env.rs b/crates/ffi/src/lean_env.rs index 1bd907d3..01020e21 100644 --- a/crates/ffi/src/lean_env.rs +++ b/crates/ffi/src/lean_env.rs @@ -321,6 +321,60 @@ fn build_collapse_const_map( map } +/// Aux-`_N` rename map for alpha-collapsed nested auxiliaries. +/// +/// When `perm` maps several source aux positions to one canonical slot, +/// aux_gen names its regenerated patches after the MIN source position +/// (`docs/ix_canonicity.md` §6.4); the other source `_N` names are address +/// aliases (in-SCC collapse) or surgered originals (evaporated auxes of a +/// split block). Either way, structural comparison of a regenerated patch +/// against a source-order original must rename the non-representative +/// `.{rec,below,brecOn}_{j+1}` (and `.brecOn_{j+1}.go/.eq`) to the +/// representative's `_N` — address equality alone does not hold for the +/// evaporated case, whose surgered originals differ in the kept-motive +/// binder position. +fn build_aux_collapse_const_map( + all0: &Name, + perm: &[usize], +) -> FxHashMap { + use ix_compile::congruence::perm::PERM_OUT_OF_SCC; + let mut map: FxHashMap = FxHashMap::default(); + let mut rep_of: FxHashMap = FxHashMap::default(); + for (j, &c) in perm.iter().enumerate() { + if c != PERM_OUT_OF_SCC { + rep_of.entry(c).or_insert(j); + } + } + for (j, &c) in perm.iter().enumerate() { + if c == PERM_OUT_OF_SCC { + continue; + } + let Some(&r) = rep_of.get(&c) else { + continue; + }; + if r == j { + continue; + } + for suffix in ["rec", "below", "brecOn"] { + let from = Name::str(all0.clone(), format!("{suffix}_{}", j + 1)); + let to = Name::str(all0.clone(), format!("{suffix}_{}", r + 1)); + map.insert(from, to); + } + for sub in ["go", "eq"] { + let from = Name::str( + Name::str(all0.clone(), format!("brecOn_{}", j + 1)), + sub.to_string(), + ); + let to = Name::str( + Name::str(all0.clone(), format!("brecOn_{}", r + 1)), + sub.to_string(), + ); + map.insert(from, to); + } + } + map +} + #[derive(Clone)] struct AuxCompareEntry { generated: ConstantInfo, @@ -1332,7 +1386,10 @@ extern "C" fn rs_tmp_decode_const_map( // class aux_gen output vs original Lean). Both sides keep `A` // and `B` distinct even under compile-time collapse, so a // collapse-driven `B → A` const_map would break the comparison. - let const_map: FxHashMap = FxHashMap::default(); + // Aux-`_N` names are the exception: the regenerated side names + // collapsed auxes after the representative (min source) position, + // so orig-side non-representative `_N` references must be renamed. + let const_map = build_aux_collapse_const_map(first, perm); Some(PermCtx { aux_perm: perm.to_vec(), @@ -2129,8 +2186,10 @@ extern "C" fn rs_compile_validate_aux( // at compile time), so collapse-driven `B → A` rewrites would // *break* the comparison rather than help. Phase 2 only needs // the nested-aux motive/minor permutation, which is encoded by - // `aux_perm` + `rec_heads` on this PermCtx. - let const_map: FxHashMap = FxHashMap::default(); + // `aux_perm` + `rec_heads` on this PermCtx — plus the aux-`_N` + // renames for collapsed auxes, whose regenerated patches use the + // representative (min source) numbering. + let const_map = build_aux_collapse_const_map(first, perm); Some(PermCtx { aux_perm: perm.to_vec(), @@ -3279,8 +3338,56 @@ extern "C" fn rs_compile_validate_aux( "Tests.Ix.Compile.Canonicity.StructureTwin1.SP.rec", "Tests.Ix.Compile.Canonicity.StructureTwin2.XP.rec", ], + // ── AuxDedup: evaporated nested auxiliaries (over-merge split) ── + // AuxDedup1 declares `A | mk : List B → List C → A` with B, C in the + // same mutual; AuxDedup2 declares C outside it. SCC splitting makes + // B and C standalone in both, every `List _` aux evaporates, and the + // canonical forms must coincide pairwise across the two declarations. + &[ + "_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", + "_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A", + ], + &[ + "_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.B", + "_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.C", + "_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.B", + "_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.C", + ], + // Evaporated aux recursors: dropping the irrelevant over-merged + // motives leaves exactly the external inductive's generic recursor, + // so every `rec_N` claim aliases `List.rec` itself. AuxDedupMixed's + // `rec_2` is the evaporated half of a mixed block (its `rec_1` stays + // a genuine canonical aux of M's own block). + // + // `List.rec` itself is deliberately NOT in the group: groups whose + // fixture names are all absent are skipped (subset envs like + // validate-aux's seed closure), and a stdlib member would make such + // a group partially present and fail as "missing names". The + // equality to `List.rec`'s address is enforced by kernel-check + // anyway — the claims only typecheck as projections of List's + // recursor block. + &[ + "_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", + "_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", + "_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", + "_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", + ], ]; + // Module markers: a fully-absent group is "not applicable" only when + // its fixture module isn't in the env at all (the standalone + // `ix validate --path ` command runs against arbitrary + // environments, e.g. Mathlib smoke tests). If the marker resolves but + // a whole group doesn't, the group has silently dropped out of + // coverage (seed-filter or compile regression) — that must FAIL, not + // skip: Phase 4b once ran `0 pass, 0 fail` for exactly this reason. + let mutual_loaded = stt + .resolve_addr(&mk_name("Tests.Ix.Compile.Mutual.AlphaCollapse.A")) + .is_some(); + let canonicity_loaded = stt + .resolve_addr(&mk_name("Tests.Ix.Compile.Canonicity.CrossNamespaceTwin1.A")) + .is_some(); + for group in groups { let addrs: Vec<_> = group .iter() @@ -3290,11 +3397,18 @@ extern "C" fn rs_compile_validate_aux( let Some((_, Some(first_addr))) = addrs.iter().find(|(_, addr)| addr.is_some()) else { - // Phase 4b fixtures live in `Tests.Ix.Compile.Canonicity`. The - // standalone `ix validate --path ` command can run against - // arbitrary environments (e.g. Mathlib smoke tests) that do not - // import those test declarations. Treat fully-absent fixture groups - // as not applicable; partial presence below remains a real failure. + let module_loaded = if group[0].contains("Tests.Ix.Compile.Mutual") { + mutual_loaded + } else { + canonicity_loaded + }; + if module_loaded { + p4b.record_fail(format!( + "group fully absent though its fixture module is loaded \ + (seed/coverage regression): {}", + group.join(", ") + )); + } continue; }; diff --git a/crates/ixon/src/metadata.rs b/crates/ixon/src/metadata.rs index c8f16d2c..e7699267 100644 --- a/crates/ixon/src/metadata.rs +++ b/crates/ixon/src/metadata.rs @@ -80,6 +80,14 @@ pub enum ExprMetaData { /// replacement argument's metadata by canonical position, while decompile /// needs the source-order `entries` to reconstruct the original spine. canon_meta: Vec, + /// `Some((sharing_idx, meta))` when the call-site HEAD itself was + /// rewritten (evaporated-aux recursors: `.rec_N` aliased to the + /// external inductive's recursor, whose universe-level arity differs). + /// Points at the ORIGINAL head expression in + /// `ConstantMeta.meta_sharing`, exactly like a `Collapsed` argument — + /// decompile uses it to restore the source head (name + original level + /// args) instead of reading levels off the stored canonical head. + orig_head: Option<(u64, u64)>, }, } @@ -843,7 +851,7 @@ impl ExprMetaData { put_mdata_stack_indexed(mdata, idx, buf)?; put_u64(*child, buf); }, - Self::CallSite { name, entries, canon_meta } => { + Self::CallSite { name, entries, canon_meta, orig_head } => { put_u8(10, buf); put_idx(name, idx, buf)?; put_vec_len(entries.len(), buf); @@ -862,6 +870,14 @@ impl ExprMetaData { } } put_u64_vec(canon_meta, buf); + match orig_head { + None => put_u8(0, buf), + Some((sharing_idx, meta)) => { + put_u8(1, buf); + put_u64(*sharing_idx, buf); + put_u64(*meta, buf); + }, + } }, } Ok(()) @@ -933,7 +949,18 @@ impl ExprMetaData { entries.push(entry); } let canon_meta = get_u64_vec(buf)?; - Ok(Self::CallSite { name, entries, canon_meta }) + let orig_head = match get_u8(buf)? { + 0 => None, + 1 => { + let sharing_idx = get_u64(buf)?; + let meta = get_u64(buf)?; + Some((sharing_idx, meta)) + }, + x => { + return Err(format!("CallSite::get: invalid orig_head tag {x}")); + }, + }; + Ok(Self::CallSite { name, entries, canon_meta, orig_head }) }, x => Err(format!("ExprMetaData::get: invalid tag {x}")), } diff --git a/crates/kernel/src/ingress.rs b/crates/kernel/src/ingress.rs index d1d5e809..5b17aa01 100644 --- a/crates/kernel/src/ingress.rs +++ b/crates/kernel/src/ingress.rs @@ -856,6 +856,7 @@ fn ingress_expr( name: cs_name, entries: _, canon_meta, + orig_head: _, } = node { // Flatten the canonical App telescope. `a_i` is the arg @@ -5063,6 +5064,7 @@ mod tests { meta: bad_entry_meta, }], canon_meta: vec![arg_canon_meta], + orig_head: None, }); let ixon = IxonExpr::app( diff --git a/docs/ix_canonicity.md b/docs/ix_canonicity.md index f6e3417d..3b6be253 100644 --- a/docs/ix_canonicity.md +++ b/docs/ix_canonicity.md @@ -646,7 +646,72 @@ the same projection address (in the inductive block for the aux inductive itself, and in the corresponding derived blocks for its `.rec`, `.below`, `.brecOn`, etc.). -### 6.5 The content-address recipe +### 6.5 Evaporated auxiliaries (over-merge splits) + +A source aux can lose its home entirely: its OWNER (the inductive +whose constructor walk discovers the occurrence) stays in an SCC while +every spec-param inductive splits into other SCCs. Example: + +```lean +mutual + inductive A | mk : List B → List C → A + inductive B | leaf + inductive C | leaf +end +``` + +SCC splitting yields `{A}`, `{B}`, `{C}`. From `{A}`'s view, `List B` +mentions no block member — it is no longer a nested occurrence at all. +Since SCCs partition the block, no SCC contains both the owner and the +specs: the aux **evaporates**. (`compute_aux_perm` marks these source +positions `PERM_OUT_OF_SCC`; an out-of-SCC entry whose owner is ALSO +out-of-SCC is just another SCC's aux, handled there.) + +The canonical form follows from the isomorphism principle: a source +declaration with `C` outside the mutual is isomorphic and never had +the extra motives, so they are irrelevant and canonicalization drops +them. Dropping the irrelevant motives/minors from `.rec_N` +leaves exactly the EXTERNAL inductive's own generic recursor — which +is also what the kernel regenerates from the external block, so no +other stored form can check. Concretely: + +- `.rec_N` claims are **address aliases of `.rec`** + (`aux_gen`'s evaporated-alias pass). All evaporated auxes with the + same external head collapse to one address, across declarations. +- Call sites are rebuilt onto the external telescope by a + **head-rewrite `CallSitePlan`**: spec args and the extended level + list are derived from the source recursor's type instantiated with + call-site args (`surgery::derive_head_rewrite_app`); the aux's own + motive maps to the external motive slot; its minor band is kept, + with `adapt_split_minor` synthesizing IHs consumed from dropped + motives (via the target's source recursor — including AUX targets, + which recurse through their own head-rewrite plans). The ORIGINAL + head (source name + source levels) is preserved in `meta_sharing`, + pointed at by `ExprMetaData::CallSite::orig_head`, and restored by + decompile. +- `.below_N` / `.brecOn_N[.go|.eq]` of evaporated auxes have no + canonical regeneration: they compile as **surgered originals** + (source telescopes kept, embedded `rec_N` spines rewritten), exactly + like `_sizeOf_N`. Their claims typecheck; address identity across + isomorphic declarations is deliberately NOT promised for these + derived definitions (their telescopes still carry the source arity). +- The rewrite domain is restricted to single-motive external targets; + unsupported shapes skip both alias and plan together and fall back + to original compilation, which kernel-check reports per constant. + +Decompile regenerates the Lean-faithful over-merged view from the +stored `Muts` metadata, and the regeneration is **byte-exact**: for +every aux constant, `roundtrip_block`'s recompile of the regenerated +form reproduces `Named.original.0` exactly (this requires mirroring +the production compile paths' `preseed_expr_tables` call — the +serialized constant embeds its ref/univ tables in preseeded sorted +order, so an unseeded recompile permutes every `Ref`/univ index into +a byte-different, semantically identical constant). A Phase-A address +mismatch is therefore a **hard error** with no aux exemption; the +recovery path (`recover_aux_from_original`) only preserves the +Lean-facing constant for diagnosis while the error is recorded. + +### 6.6 The content-address recipe Each block's content hash is computed from its **members array in canonical layout order**. The aux permutation and the Lean-visible From fb00cf56e9d0203863a90e680413e069c9d1bed3 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Sat, 4 Jul 2026 02:20:28 -0400 Subject: [PATCH 3/5] chore: fix clippy warnings and fmt drift Behavior-neutral cleanups flagged by `cargo clippy --all-targets`: map_or over map+unwrap_or and slice::contains in surgery.rs, an enumerate loop for the motive-peeling walk in aux_motive_sigs, and let-chain collapses for the inductive-flags fixup loops in decompile.rs and kernel_egress.rs. Plus `cargo fmt` line-wrapping drift left over from the previous commit. --- crates/compile/src/compile.rs | 27 ++++++++++------- crates/compile/src/compile/aux_gen.rs | 3 +- crates/compile/src/compile/surgery.rs | 37 ++++++++++------------- crates/compile/src/decompile.rs | 42 +++++++++++++-------------- crates/compile/src/kernel_egress.rs | 8 ++--- crates/ffi/src/lean_env.rs | 4 ++- 6 files changed, 60 insertions(+), 61 deletions(-) diff --git a/crates/compile/src/compile.rs b/crates/compile/src/compile.rs index d48400ea..0200d9af 100644 --- a/crates/compile/src/compile.rs +++ b/crates/compile/src/compile.rs @@ -857,20 +857,25 @@ pub fn compile_expr( + plan.n_source_minors..]; let (target_levels, specs) = surgery::derive_head_rewrite_app( - name, levels, &hr, params, motives, lean_env_ref, + name, + levels, + &hr, + params, + motives, + lean_env_ref, ) - .map_err(|e| CompileError::InvalidMutualBlock { - reason: format!( - "head-rewrite for '{}': {e}", - name.pretty() - ), + .map_err(|e| { + CompileError::InvalidMutualBlock { + reason: format!( + "head-rewrite for '{}': {e}", + name.pretty() + ), + } })?; - let mut canonical_args: Vec = - Vec::with_capacity( - specs.len() + 1 + plan.n_canonical_minors() - + tail.len(), - ); + let mut canonical_args: Vec = Vec::with_capacity( + specs.len() + 1 + plan.n_canonical_minors() + tail.len(), + ); let mut collapsed_args: Vec = Vec::new(); let mut entries: Vec = Vec::new(); diff --git a/crates/compile/src/compile/aux_gen.rs b/crates/compile/src/compile/aux_gen.rs index 447a79fc..9e90449e 100644 --- a/crates/compile/src/compile/aux_gen.rs +++ b/crates/compile/src/compile/aux_gen.rs @@ -942,7 +942,8 @@ pub fn generate_aux_patches( && let Some(first_orig_name) = original_all.first() { let in_scc: FxHashSet<&Name> = sorted_classes.iter().flatten().collect(); - let src_order = nested::source_aux_order_with_owner(original_all, lean_env)?; + let src_order = + nested::source_aux_order_with_owner(original_all, lean_env)?; for (source_j, &canonical_i) in perm.iter().enumerate() { if canonical_i != nested::PERM_OUT_OF_SCC { continue; diff --git a/crates/compile/src/compile/surgery.rs b/crates/compile/src/compile/surgery.rs index 72d8489a..de8d70ca 100644 --- a/crates/compile/src/compile/surgery.rs +++ b/crates/compile/src/compile/surgery.rs @@ -33,7 +33,7 @@ use ixon::expr::Expr as IxonExpr; use super::{ aux_gen::expr_utils::{ LocalDecl, consume_type_annotations, decompose_apps, fresh_fvar, - instantiate1, instantiate_rev, mk_lambda, subst_levels, + instantiate_rev, instantiate1, mk_lambda, subst_levels, }, nat_conv::nat_to_usize, }; @@ -342,15 +342,13 @@ pub fn compute_call_site_plans( // evaporated with the SCC split), not the source count. Falling through // to `n_source_aux_motives` there would resurrect phantom canonical // slots and misalign every motive/minor mapping below. - let aux_canonical_count = aux_perm - .map(|p| { - p.iter() - .copied() - .filter(|&c| c != PERM_OUT_OF_SCC) - .max() - .map_or(0, |m| m + 1) - }) - .unwrap_or(n_source_aux_motives); + let aux_canonical_count = aux_perm.map_or(n_source_aux_motives, |p| { + p.iter() + .copied() + .filter(|&c| c != PERM_OUT_OF_SCC) + .max() + .map_or(0, |m| m + 1) + }); let aux_canon_of_source = |source_aux_j: usize| -> Option { match aux_perm.and_then(|p| p.get(source_aux_j).copied()) { @@ -643,7 +641,7 @@ pub fn compute_call_site_plans( let mut source_to_canon_motive = vec![0usize; n_source_motives]; source_to_canon_motive[x_pos] = 0; let counts: &[usize] = - aux_layout.map(|l| l.source_ctor_counts.as_slice()).unwrap_or(&[]); + aux_layout.map_or(&[], |l| l.source_ctor_counts.as_slice()); let band_start: usize = n_user_minors + counts.iter().take(aux_j).sum::(); let band_len = counts.get(aux_j).copied().unwrap_or(0); @@ -713,8 +711,7 @@ pub fn compute_call_site_plans( { // (owner, external head) per source aux — only needed when some source // aux is out-of-SCC, i.e. potentially evaporated. - let any_out = aux_perm - .is_some_and(|p| p.iter().any(|&c| c == PERM_OUT_OF_SCC)); + let any_out = aux_perm.is_some_and(|p| p.contains(&PERM_OUT_OF_SCC)); let src_owner_heads: Vec<(Name, Name)> = if any_out { crate::compile::aux_gen::nested::source_aux_order_with_owner( original_all, @@ -1026,7 +1023,7 @@ fn aux_motive_sigs( _ => return out, } } - for m_idx in 0..n_motives.min(motives.len()) { + for (m_idx, motive) in motives.iter().enumerate().take(n_motives) { let next = match cur.as_data() { ExprData::ForallE(_, dom, body, _, _) => { if m_idx >= n_user { @@ -1059,7 +1056,7 @@ fn aux_motive_sigs( } } } - instantiate_rev(body, std::slice::from_ref(&motives[m_idx])) + instantiate_rev(body, std::slice::from_ref(motive)) }, _ => return out, }; @@ -1088,8 +1085,7 @@ pub fn derive_head_rewrite_app( return Err(format!("'{}' is not a recursor", rec_name.pretty())); }; let sigs = aux_motive_sigs(rec, rec_levels, params, motives, lean_env); - let Some(sig) = - sigs.iter().find(|s| s.source_pos == hr.target_motive_pos) + let Some(sig) = sigs.iter().find(|s| s.source_pos == hr.target_motive_pos) else { return Err(format!( "no aux motive signature at position {}", @@ -1108,8 +1104,7 @@ pub fn derive_head_rewrite_app( let occ_levels = { let mut cur = subst_levels(&rec.cnst.typ, &rec.cnst.level_params, rec_levels); - for arg in params.iter().chain(motives.iter().take(hr.target_motive_pos)) - { + for arg in params.iter().chain(motives.iter().take(hr.target_motive_pos)) { match cur.as_data() { // Shift-aware substitution — args may reference the caller's // telescope (see `source_minor_type`). @@ -1265,9 +1260,7 @@ fn find_source_rec_target( let ExprData::Const(target_name, _, _) = head.as_data() else { return None; }; - if let Some(source_pos) = - original_all.iter().position(|n| n == target_name) - { + if let Some(source_pos) = original_all.iter().position(|n| n == target_name) { let target_n_params = match lean_env.get(target_name)? { LeanConstantInfo::InductInfo(ind) => nat_to_usize(&ind.num_params), _ => return None, diff --git a/crates/compile/src/decompile.rs b/crates/compile/src/decompile.rs index a720ec23..56a7ab62 100644 --- a/crates/compile/src/decompile.rs +++ b/crates/compile/src/decompile.rs @@ -822,8 +822,7 @@ pub fn decompile_expr( // level args) lives in meta_sharing, pointed at by // `orig_head` — decompile that instead. Otherwise rebuild the // head from the CallSite name + the stored head's levels. - let orig_head_frame = if let Some((sharing_idx, meta)) = orig_head - { + let orig_head_frame = if let Some((sharing_idx, meta)) = orig_head { let head_share = cache .meta_sharing .get(*sharing_idx as usize) @@ -2442,7 +2441,11 @@ fn ixon_content_address(constant: &Constant) -> Address { /// types can be identical while these differ (`hints`/`all` are metadata, /// not hashed — they can never cause an address mismatch). Used by the /// `IX_ROUNDTRIP_DEBUG` mismatch dump in `roundtrip_block`. -fn ixon_mut_const_summary(label: &str, class_idx: usize, mc: &MutConst) -> String { +fn ixon_mut_const_summary( + label: &str, + class_idx: usize, + mc: &MutConst, +) -> String { let ehash = |e: &Arc| -> String { let mut b = Vec::new(); ixon::serialize::put_expr(e, &mut b); @@ -2538,11 +2541,8 @@ fn roundtrip_block( } preseed_expr_tables(&exprs, &mut_ctx, &mut cache, stt, "roundtrip_block") .map_err(|e| DecompileError::BadConstantFormat { - msg: format!( - "roundtrip preseed {}: {e}", - consts[0].name().pretty() - ), - })?; + msg: format!("roundtrip preseed {}: {e}", consts[0].name().pretty()), + })?; } // Map from name → (class_idx, MutConst kind) for projection construction. @@ -2846,8 +2846,7 @@ fn roundtrip_block( }); match compiled { Ok(data) => { - let prefs: Vec
= - pcache.refs.iter().cloned().collect(); + let prefs: Vec
= pcache.refs.iter().cloned().collect(); let punivs: Vec> = pcache.univs.iter().cloned().collect(); let result = match &data { @@ -3816,8 +3815,7 @@ fn recover_aux_from_original( return false; }; let had_entry = dstt.env.contains_key(name); - let synthetic = - Named { addr: orig_addr, meta: orig_meta, original: None }; + let synthetic = Named { addr: orig_addr, meta: orig_meta, original: None }; if decompile_named_const(name, &synthetic, stt, dstt).is_err() { return false; } @@ -4713,10 +4711,10 @@ pub fn decompile_env( dstt.env.iter().map(|e| (e.key().clone(), e.value().clone())).collect(); let mut groups: FxHashMap> = FxHashMap::default(); for entry in dstt.env.iter() { - if let LeanConstantInfo::InductInfo(v) = entry.value() { - if let Some(first) = v.all.first() { - groups.entry(first.clone()).or_insert_with(|| v.all.clone()); - } + if let LeanConstantInfo::InductInfo(v) = entry.value() + && let Some(first) = v.all.first() + { + groups.entry(first.clone()).or_insert_with(|| v.all.clone()); } } for (key, all) in &groups { @@ -4726,12 +4724,12 @@ pub fn decompile_env( } })?; for member in all { - if let Some(mut entry) = dstt.env.get_mut(member) { - if let LeanConstantInfo::InductInfo(v) = entry.value_mut() { - v.num_nested = Nat::from(flags.num_nested); - v.is_rec = flags.is_rec; - v.is_reflexive = flags.is_reflexive; - } + if let Some(mut entry) = dstt.env.get_mut(member) + && let LeanConstantInfo::InductInfo(v) = entry.value_mut() + { + v.num_nested = Nat::from(flags.num_nested); + v.is_rec = flags.is_rec; + v.is_reflexive = flags.is_reflexive; } } } diff --git a/crates/compile/src/kernel_egress.rs b/crates/compile/src/kernel_egress.rs index becbb8db..a0ba4184 100644 --- a/crates/compile/src/kernel_egress.rs +++ b/crates/compile/src/kernel_egress.rs @@ -305,10 +305,10 @@ pub fn lean_egress(zenv: &KEnv) -> Result { let groups: DashMap> = DashMap::new(); entries.into_par_iter().for_each(|(id, zc)| { let ci = egress_constant(&zc); - if let LeanCI::InductInfo(v) = &ci { - if let Some(first) = v.all.first() { - groups.entry(first.clone()).or_insert_with(|| v.all.clone()); - } + if let LeanCI::InductInfo(v) = &ci + && let Some(first) = v.all.first() + { + groups.entry(first.clone()).or_insert_with(|| v.all.clone()); } egressed.insert(id.name.clone(), ci); }); diff --git a/crates/ffi/src/lean_env.rs b/crates/ffi/src/lean_env.rs index 01020e21..776070f6 100644 --- a/crates/ffi/src/lean_env.rs +++ b/crates/ffi/src/lean_env.rs @@ -3385,7 +3385,9 @@ extern "C" fn rs_compile_validate_aux( .resolve_addr(&mk_name("Tests.Ix.Compile.Mutual.AlphaCollapse.A")) .is_some(); let canonicity_loaded = stt - .resolve_addr(&mk_name("Tests.Ix.Compile.Canonicity.CrossNamespaceTwin1.A")) + .resolve_addr(&mk_name( + "Tests.Ix.Compile.Canonicity.CrossNamespaceTwin1.A", + )) .is_some(); for group in groups { From d8b11c08c9c224ae2dc8f7e652de402cbd7e11cd Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Wed, 1 Jul 2026 08:41:34 -0700 Subject: [PATCH 4/5] IxVM Aiur kernel: fix Lean.Syntax.rec (shard 53) aux-recursor gen MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three interlocking bugs in the Aiur block-flattening / recursor-type builder caused `ix check --interp bytecode Lean.Syntax.rec` to fail with `assert_eq mismatch: 0 != 1` on the declared-vs-canonical type equality: - `build_flat_block` traversed originals once; nested-aux members (`Array Syntax`, `List Syntax`) never had their own ctors scanned, so `flat` had 2 motives when Lean's recursor declares 3. Replaced with a queue-based fixed point mirroring `crates/kernel/src/inductive.rs: build_flat_block:531-599`. - `is_rec_field` classified any ctor field as recursive when its spine head Const-idx matched a flat member's ind idx. For `Lean.Syntax.ident`, the field `preresolved : List Preresolved` shares the base List const idx with the block's `List Lean.Syntax` aux and got a spurious `motive_2 preresolved` IH binder. Match key is now (head_idx, spine-arg prefix ≡ member.spec_params) — direct members carry `spec_params = []` and match on idx alone, auxes require the concrete occurrence. - `build_all_minors` was iterating `flat` and passing the shrinking suffix into `build_minor_doms`, so field classification for later members was blind to earlier members. Split into a wrapper + `build_all_minors_walk` that pins the caller's full flat while the iteration state shrinks. Pin `Lean.Syntax.rec` in the ixvm test suite; rebump every FFT cost shifted by the codegen refresh (`ix codegen`). --- Ix/IxVM/Kernel/Inductive.lean | 306 +- Tests/Ix/IxVM.lean | 77 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 8524 ++++++++++++++------------ 3 files changed, 4908 insertions(+), 3999 deletions(-) diff --git a/Ix/IxVM/Kernel/Inductive.lean b/Ix/IxVM/Kernel/Inductive.lean index 1fa5e8dc..101cbe33 100644 --- a/Ix/IxVM/Kernel/Inductive.lean +++ b/Ix/IxVM/Kernel/Inductive.lean @@ -813,7 +813,9 @@ def inductive_check := ⟦ -- ============================================================================ fn build_minor_at_depth(ind_idx: G, ctor_idx: G, ctor_ty: KExpr, is_aux: G, spec_params: List‹KExpr›, - occurrence_us: List‹KLevel›, flat_idxs: List‹G›, + occurrence_us: List‹KLevel›, + flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, + flat_idxs: List‹G›, flat_own_params: List‹G›, n_rec_params: G, n_motives: G, prev_minors: G, motive_base: G, @@ -829,7 +831,7 @@ def inductive_check := ⟦ minor_saved, is_aux, spec_params, 0); let self_mem_pair = find_member_local_idx(flat_idxs, ind_idx, 0); let self_mem_idx = match self_mem_pair { (_, m) => m, }; - let walk = walk_fields_classify(after_params, flat_idxs, store(ListNode.Nil), + let walk = walk_fields_classify(after_params, flat, store(ListNode.Nil), store(ListNode.Nil), store(ListNode.Nil), store(ListNode.Nil), top, addrs, 0); match walk { @@ -894,7 +896,7 @@ def inductive_check := ⟦ -- A field is recursive (direct case) when its spine head is Const(ind_idx). -- Builds accumulators with O(1) cons (prepend) and reverses once at end — -- O(F) total vs O(F²) with snoc. - fn walk_fields_classify(ty: KExpr, block_member_idxs: List‹G›, + fn walk_fields_classify(ty: KExpr, flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, doms_acc: List‹KExpr›, rec_acc: List‹G›, rec_mem_acc: List‹G›, types: List‹KExpr›, @@ -902,17 +904,17 @@ def inductive_check := ⟦ fidx: G) -> (List‹KExpr›, List‹G›, List‹G›, KExpr) { match load(ty) { KExprNode.Forall(dom, body) => - let r = is_rec_field(dom, block_member_idxs, types, top, addrs); + let r = is_rec_field(dom, flat, types, top, addrs); let new_doms = store(ListNode.Cons(dom, doms_acc)); let types2 = store(ListNode.Cons(dom, types)); match r { (1, mem_idx) => let new_rec = store(ListNode.Cons(fidx, rec_acc)); let new_mem = store(ListNode.Cons(mem_idx, rec_mem_acc)); - walk_fields_classify(body, block_member_idxs, new_doms, new_rec, new_mem, + walk_fields_classify(body, flat, new_doms, new_rec, new_mem, types2, top, addrs, fidx + 1), _ => - walk_fields_classify(body, block_member_idxs, new_doms, rec_acc, rec_mem_acc, + walk_fields_classify(body, flat, new_doms, rec_acc, rec_mem_acc, types2, top, addrs, fidx + 1), }, _ => (list_reverse(doms_acc), list_reverse(rec_acc), list_reverse(rec_mem_acc), ty), @@ -972,13 +974,16 @@ def inductive_check := ⟦ } -- Mirror: src/ix/kernel/inductive.rs:2968-3019 fn is_rec_field. - -- Returns (is_rec, member_local_idx) where member_local_idx is the - -- position of the head idx within block_member_idxs (0 for direct). - -- Returns (0, 0) if not recursive. WHNFs the per-field body so that - -- ctor field types written via reducible defs (e.g. `constType (n α) - -- (n α)`) collapse to expose the underlying inductive head, mirroring - -- the Rust kernel's whnf inside `is_rec_field`. - fn is_rec_field(dom: KExpr, block_member_idxs: List‹G›, + -- Returns (is_rec, member_local_idx) where member_local_idx is the position + -- within `flat` of the matching entry (0 for direct member). Returns (0, 0) + -- if not recursive. WHNFs the per-field body so that ctor field types written + -- via reducible defs collapse to expose the underlying inductive head. The + -- match key is (head_const_idx, spine_arg_prefix ≡ flat.spec_params) — const + -- idx alone is not enough because a nested aux (e.g. `List Lean.Syntax`) + -- shares the base ind's idx with unrelated occurrences (e.g. `List + -- Preresolved`); using idx alone would false-positive the unrelated field + -- as recursive and inject a spurious IH binder. + fn is_rec_field(dom: KExpr, flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, types: List‹KExpr›, top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, G) { match peel_leading_foralls(dom) { @@ -986,15 +991,57 @@ def inductive_check := ⟦ let inner_types = list_concat(list_reverse(doms), types); let body_w = whnf(body, inner_types, top, addrs); match collect_spine(body_w) { - (head, _) => + (head, spine_args) => match load(head) { - KExprNode.Const(idx, _) => find_member_local_idx(block_member_idxs, idx, 0), + KExprNode.Const(idx, _) => find_flat_member_match(flat, idx, spine_args, 0), _ => (0, 0), }, }, } } + -- Walk `flat`; return (1, i) at the first entry whose idx == head_idx AND + -- whose spec_params structurally match the leading `|spec_params|` entries + -- of the field's spine args. Original members have spec_params=[] so any + -- field whose head is the original ind matches. Auxes carry their concrete + -- occurrence, so only fields applied to that exact occurrence match. + fn find_flat_member_match(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, + head_idx: G, spine_args: List‹KExpr›, + i: G) -> (G, G) { + match load(flat) { + ListNode.Nil => (0, 0), + ListNode.Cons(entry, rest) => + match entry { + (fidx, _, fsps, _) => + match fidx - head_idx { + 0 => + match spine_prefix_eq(spine_args, fsps) { + 1 => (1, i), + _ => find_flat_member_match(rest, head_idx, spine_args, i + 1), + }, + _ => find_flat_member_match(rest, head_idx, spine_args, i + 1), + }, + }, + } + } + + -- Structural prefix compare: 1 iff `spec_params` is a prefix of `spine_args` + -- under `kexpr_struct_eq`. Empty spec_params always matches. + fn spine_prefix_eq(spine_args: List‹KExpr›, spec_params: List‹KExpr›) -> G { + match load(spec_params) { + ListNode.Nil => 1, + ListNode.Cons(sp, sps_rest) => + match load(spine_args) { + ListNode.Nil => 0, + ListNode.Cons(sa, sa_rest) => + match kexpr_struct_eq(sa, sp) { + 1 => spine_prefix_eq(sa_rest, sps_rest), + _ => 0, + }, + }, + } + } + -- Find target's index within block_member_idxs. (1, idx) if found else (0, 0). fn find_member_local_idx(idxs: List‹G›, target: G, i: G) -> (G, G) { match load(idxs) { @@ -1106,7 +1153,9 @@ def inductive_check := ⟦ -- to use for the ctor head; flat_idxs is used for rec field detection. fn build_minor_doms(ctor_indices: List‹G›, ind_idx: G, is_aux: G, spec_params: List‹KExpr›, - occurrence_us: List‹KLevel›, flat_idxs: List‹G›, + occurrence_us: List‹KLevel›, + flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, + flat_idxs: List‹G›, flat_own_params: List‹G›, n_rec_params: G, n_motives: G, motive_base: G, @@ -1120,11 +1169,11 @@ def inductive_check := ⟦ KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _) => let minor = build_minor_at_depth(ind_idx, ctor_idx, ctor_ty, is_aux, spec_params, occurrence_us, - flat_idxs, flat_own_params, + flat, flat_idxs, flat_own_params, n_rec_params, n_motives, prev_minors, motive_base, top, addrs); let rest_minors = build_minor_doms(rest, ind_idx, is_aux, spec_params, - occurrence_us, flat_idxs, + occurrence_us, flat, flat_idxs, flat_own_params, n_rec_params, n_motives, motive_base, @@ -1189,6 +1238,23 @@ def inductive_check := ⟦ ind_lvls: G, univ_offset: G, motive_base: G, top: List‹&KConstantInfo›, addrs: List‹Addr›, prev_minors: G) -> List‹KExpr› { + build_all_minors_walk(flat, flat, flat_idxs, flat_own_params, + n_rec_params, n_motives, ind_lvls, univ_offset, + motive_base, top, addrs, prev_minors) + } + + -- `full_flat` stays pinned to the caller's original flat list so + -- `is_rec_field` sees every block member for spec_params matching; `flat` + -- shrinks as we iterate members. Bug guarded against: previously we passed + -- the shrinking `flat` into `build_minor_doms`, which made later members' + -- ctor-field classification blind to earlier members. + fn build_all_minors_walk(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, + full_flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, + flat_idxs: List‹G›, flat_own_params: List‹G›, + n_rec_params: G, n_motives: G, + ind_lvls: G, univ_offset: G, motive_base: G, + top: List‹&KConstantInfo›, addrs: List‹Addr›, + prev_minors: G) -> List‹KExpr› { match load(flat) { ListNode.Nil => store(ListNode.Nil), ListNode.Cons(m, rest) => @@ -1198,19 +1264,22 @@ def inductive_check := ⟦ match ci { KConstantInfo.Induct(_, _, _, _, m_ctor_indices, _, _, _, _, _) => let m_minors = build_minor_doms(m_ctor_indices, member_idx, - is_aux, spec_params, occ_us, flat_idxs, + is_aux, spec_params, occ_us, + full_flat, flat_idxs, flat_own_params, n_rec_params, n_motives, motive_base, top, addrs, prev_minors); let added = list_length(m_minors); - let rest_minors = build_all_minors(rest, flat_idxs, flat_own_params, + let rest_minors = build_all_minors_walk(rest, full_flat, + flat_idxs, flat_own_params, n_rec_params, n_motives, ind_lvls, univ_offset, motive_base, top, addrs, prev_minors + added); list_concat(m_minors, rest_minors), _ => - build_all_minors(rest, flat_idxs, flat_own_params, + build_all_minors_walk(rest, full_flat, + flat_idxs, flat_own_params, n_rec_params, n_motives, ind_lvls, univ_offset, motive_base, top, addrs, prev_minors), }, @@ -1331,6 +1400,7 @@ def inductive_check := ⟦ ind_lvls: G, univ_offset: G, motive_doms: List‹KExpr›, minor_doms: List‹KExpr›, param_doms: List‹KExpr›, peer_recs: List‹G›, + flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, flat_idxs: List‹G›, flat_own_params: List‹G›, is_aux: G, spec_params: List‹KExpr›, occurrence_us: List‹KLevel›, @@ -1349,7 +1419,7 @@ def inductive_check := ⟦ let n_own_params = ctor_num_params_of(ctor_idx, top); let after_params = peel_rule_ctor_params(ctor_ty_inst, n_own_params, is_aux, spec_params); - let walk = walk_fields_classify(after_params, flat_idxs, store(ListNode.Nil), + let walk = walk_fields_classify(after_params, flat, store(ListNode.Nil), store(ListNode.Nil), store(ListNode.Nil), store(ListNode.Nil), top, addrs, 0); match walk { @@ -1664,6 +1734,70 @@ def inductive_check := ⟦ } } + -- Structural KExpr equality (heads + payload only; ignores universes/binder + -- names). Used to compare a ctor field's spine-arg prefix against a flat + -- aux member's spec_params in `is_rec_field`, where content-addressed exprs + -- from the same block-flattening pass are guaranteed to be structurally + -- comparable without WHNF. + fn kexpr_struct_eq(a: KExpr, b: KExpr) -> G { + match load(a) { + KExprNode.BVar(ia) => + match load(b) { + KExprNode.BVar(ib) => + match (u32_less_than(ia, ib) + u32_less_than(ib, ia)) { + 0 => 1, + _ => 0, + }, + _ => 0, + }, + KExprNode.Srt(_) => + match load(b) { + KExprNode.Srt(_) => 1, + _ => 0, + }, + KExprNode.Const(ca, _) => + match load(b) { + KExprNode.Const(cb, _) => + match (u32_less_than(ca, cb) + u32_less_than(cb, ca)) { + 0 => 1, + _ => 0, + }, + _ => 0, + }, + KExprNode.App(fa, aa) => + match load(b) { + KExprNode.App(fb, ab) => + let feq = kexpr_struct_eq(fa, fb); + match feq { + 1 => kexpr_struct_eq(aa, ab), + _ => 0, + }, + _ => 0, + }, + KExprNode.Lam(ta, ba) => + match load(b) { + KExprNode.Lam(tb, bb) => + let teq = kexpr_struct_eq(ta, tb); + match teq { + 1 => kexpr_struct_eq(ba, bb), + _ => 0, + }, + _ => 0, + }, + KExprNode.Forall(da, xa) => + match load(b) { + KExprNode.Forall(db, xb) => + let deq = kexpr_struct_eq(da, db); + match deq { + 1 => kexpr_struct_eq(xa, xb), + _ => 0, + }, + _ => 0, + }, + _ => 0, + } + } + fn check_recursor_member(rec_idx: G, ci_rec: KConstantInfo, top: List‹&KConstantInfo›, addrs: List‹Addr›) { match ci_rec { @@ -1730,7 +1864,7 @@ def inductive_check := ⟦ ind_n_params, n_motives, n_minors, ind_lvls, univ_offset, motive_doms, minor_doms, param_doms, - peer_recs, flat_idxs, flat_own_params, + peer_recs, flat, flat_idxs, flat_own_params, self_is_aux, self_spec_params, self_occ_us, top, addrs, ctor_pos_offset); compare_rules(rules, canonical_rules, top, addrs), @@ -1747,13 +1881,115 @@ def inductive_check := ⟦ -- auxes: is_aux=1, ind_idx=ext_ind_idx, spec_params=detected substitution -- exprs, occurrence_us = univ args from the actual nested ref. -- Mirror: src/ix/kernel/inductive.rs:490-601 build_flat_block. + -- Queue-based fixed-point build. Mirror `crates/kernel/src/inductive.rs` + -- `build_flat_block:531-599`. Seed with originals, then iteratively scan + -- every discovered member's ctors for further nested occurrences; every + -- newly-detected aux gets pushed onto the flat list AND its own ctors + -- scanned in the next round. fn build_flat_block(block_member_idxs: List‹G›, univ_offset: G, top: List‹&KConstantInfo›) -> List‹(G, G, List‹KExpr›, List‹KLevel›)› { let originals = build_flat_originals(block_member_idxs, univ_offset, top); - let nested = gather_block_nested(block_member_idxs, block_member_idxs, top); - let auxes = build_flat_auxes(nested); - list_concat(originals, auxes) + build_flat_block_iter(originals, 0, block_member_idxs, top) + } + + fn build_flat_block_iter(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, + qi: G, block_member_idxs: List‹G›, + top: List‹&KConstantInfo›) + -> List‹(G, G, List‹KExpr›, List‹KLevel›)› { + let n = list_length(flat); + let more = u32_less_than(qi, n); + match more { + 0 => flat, + _ => + let member = flat_member_at(flat, qi); + match member { + (m_idx, is_aux, sp, ou) => + let new_triples = detect_nested_in_member(m_idx, is_aux, sp, ou, + block_member_idxs, top); + let flat_updated = flat_append_new_auxes(flat, new_triples); + build_flat_block_iter(flat_updated, qi + 1, block_member_idxs, top), + }, + } + } + + fn detect_nested_in_member(m_idx: G, is_aux: G, + spec_params: List‹KExpr›, + occ_us: List‹KLevel›, + block_idxs: List‹G›, + top: List‹&KConstantInfo›) + -> List‹(G, List‹KExpr›, List‹KLevel›)› { + let ci = load(list_lookup(top, m_idx)); + match ci { + KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, _, _, _, _) => + detect_nested_in_member_ctors(ctor_indices, n_params, is_aux, + spec_params, occ_us, block_idxs, top), + _ => store(ListNode.Nil), + } + } + + fn detect_nested_in_member_ctors(ctor_indices: List‹G›, n_params: G, + is_aux: G, spec_params: List‹KExpr›, + occ_us: List‹KLevel›, + block_idxs: List‹G›, + top: List‹&KConstantInfo›) + -> List‹(G, List‹KExpr›, List‹KLevel›)› { + match load(ctor_indices) { + ListNode.Nil => store(ListNode.Nil), + ListNode.Cons(ctor_idx, rest) => + let ctor_ci = load(list_lookup(top, ctor_idx)); + match ctor_ci { + KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _) => + let body = match is_aux { + 0 => peel_n_foralls_tolerant(ctor_ty, n_params), + _ => + let ctor_ty_inst = expr_inst_levels(ctor_ty, occ_us); + synth_aux_ctor_ty(ctor_ty_inst, n_params, spec_params), + }; + let from_this = detect_nested_in_field_chain(body, block_idxs, top); + let from_rest = detect_nested_in_member_ctors(rest, n_params, is_aux, + spec_params, occ_us, + block_idxs, top); + list_concat(from_this, from_rest), + _ => detect_nested_in_member_ctors(rest, n_params, is_aux, + spec_params, occ_us, block_idxs, top), + }, + } + } + + fn flat_append_new_auxes(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, + new_triples: List‹(G, List‹KExpr›, List‹KLevel›)›) + -> List‹(G, G, List‹KExpr›, List‹KLevel›)› { + match load(new_triples) { + ListNode.Nil => flat, + ListNode.Cons(t, rest) => + match t { + (idx, sp, ou) => + match flat_contains_idx(flat, idx) { + 1 => flat_append_new_auxes(flat, rest), + _ => + let singleton = store(ListNode.Cons((idx, 1, sp, ou), + store(ListNode.Nil))); + let flat_appended = list_concat(flat, singleton); + flat_append_new_auxes(flat_appended, rest), + }, + }, + } + } + + fn flat_contains_idx(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, + target_idx: G) -> G { + match load(flat) { + ListNode.Nil => 0, + ListNode.Cons(m, rest) => + match m { + (idx, _is_aux, _sp, _ou) => + match (u32_less_than(idx, target_idx) + u32_less_than(target_idx, idx)) { + 0 => 1, + _ => flat_contains_idx(rest, target_idx), + }, + }, + } } fn build_flat_originals(block_member_idxs: List‹G›, univ_offset: G, @@ -1775,19 +2011,6 @@ def inductive_check := ⟦ } } - fn build_flat_auxes(nested: List‹(G, List‹KExpr›, List‹KLevel›)›) - -> List‹(G, G, List‹KExpr›, List‹KLevel›)› { - match load(nested) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(p, rest) => - match p { - (ext_idx, sps, occ_us) => - store(ListNode.Cons((ext_idx, 1, sps, occ_us), - build_flat_auxes(rest))), - }, - } - } - -- Project per-member ind_idx from flat list. fn flat_ind_idxs(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›) -> List‹G› { match load(flat) { @@ -2229,6 +2452,7 @@ def inductive_check := ⟦ ind_lvls: G, univ_offset: G, motive_doms: List‹KExpr›, minor_doms: List‹KExpr›, param_doms: List‹KExpr›, peer_recs: List‹G›, + flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, flat_idxs: List‹G›, flat_own_params: List‹G›, is_aux: G, spec_params: List‹KExpr›, occurrence_us: List‹KLevel›, @@ -2243,13 +2467,13 @@ def inductive_check := ⟦ let rhs = build_rule_rhs(rec_idx, owning_ind, ctor_idx, ctor_ty, ctor_pos, n_params, n_motives, n_minors, ind_lvls, univ_offset, motive_doms, minor_doms, param_doms, peer_recs, - flat_idxs, flat_own_params, + flat, flat_idxs, flat_own_params, is_aux, spec_params, occurrence_us, top, addrs); let rule = KRecRule.Mk(ctor_idx, n_fields, rhs); store(ListNode.Cons(rule, populate_rules(rec_idx, ind_idx, rest, n_params, n_motives, n_minors, ind_lvls, univ_offset, motive_doms, minor_doms, param_doms, - peer_recs, flat_idxs, flat_own_params, + peer_recs, flat, flat_idxs, flat_own_params, is_aux, spec_params, occurrence_us, top, addrs, ctor_pos + 1))), }, diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index cadb0530..bb234c3d 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -123,52 +123,55 @@ public def kernelCheck (name : Lean.Name) (env : Lean.Environment) : private def kernelCheckEntries : List (String × Nat) := [ -- Stdlib ("HEq", 1_713_377), - ("HEq.rec", 2_673_812), - ("Eq.rec", 2_569_093), + ("HEq.rec", 2_674_051), + ("Eq.rec", 2_569_332), ("Nat", 1_856_206), - ("Nat.add", 12_913_896), - ("Nat.add_comm", 53_941_716), - ("Nat.decEq", 68_096_944), - ("Nat.decLe", 189_429_058), - ("Nat.sub_le_of_le_add", 510_307_972), + ("Nat.add", 12_914_350), + ("Nat.add_comm", 53_942_913), + ("Nat.decEq", 68_100_321), + ("Nat.decLe", 189_439_889), + ("Nat.sub_le_of_le_add", 510_322_250), -- Newly-unlocked targets (level_leq Géran normalize). ("Trans.mk", 2_846_339), - ("Array.append_assoc", 2_533_794_863), - ("Vector.append", 2_604_106_735), + ("Array.append_assoc", 2_533_821_272), + ("Vector.append", 2_604_133_144), -- Primitive reduction theorems (`IxVMPrim`) - ("IxVMPrim.nat_add_lit", 27_892_351), - ("IxVMPrim.nat_sub_lit", 33_496_649), - ("IxVMPrim.nat_mul_lit", 24_496_901), - ("IxVMPrim.nat_mul_big", 23_999_554), - ("IxVMPrim.nat_div_lit", 363_376_868), - ("IxVMPrim.nat_mod_lit", 372_058_694), + ("IxVMPrim.nat_add_lit", 27_892_805), + ("IxVMPrim.nat_sub_lit", 33_497_103), + ("IxVMPrim.nat_mul_lit", 24_497_355), + ("IxVMPrim.nat_mul_big", 24_000_008), + ("IxVMPrim.nat_div_lit", 363_389_222), + ("IxVMPrim.nat_mod_lit", 372_071_049), ("IxVMPrim.nat_succ_lit", 7_291_627), - ("IxVMPrim.nat_pred_lit", 14_654_021), - ("IxVMPrim.nat_gcd_lit", 599_139_076), - ("IxVMPrim.nat_land_lit", 1_008_587_524), - ("IxVMPrim.nat_lor_lit", 1_009_390_333), - ("IxVMPrim.nat_xor_lit", 1_017_980_364), - ("IxVMPrim.nat_shl_lit", 34_588_323), - ("IxVMPrim.nat_shr_lit", 368_712_426), - ("IxVMPrim.nat_pow_big", 71_440_452), - ("IxVMPrim.nat_beq_lit", 24_003_617), - ("IxVMPrim.nat_ble_lit", 22_333_231), - ("IxVMPrim.nat_dec_le", 195_956_041), - ("IxVMPrim.nat_dec_lt", 199_899_015), - ("IxVMPrim.nat_dec_eq", 81_741_042), - ("IxVMPrim.str_size_lit", 715_801_486), - ("IxVMPrim.bv_to_nat_lit", 570_773_030), + ("IxVMPrim.nat_pred_lit", 14_654_475), + ("IxVMPrim.nat_gcd_lit", 599_154_968), + ("IxVMPrim.nat_land_lit", 1_008_609_362), + ("IxVMPrim.nat_lor_lit", 1_009_412_171), + ("IxVMPrim.nat_xor_lit", 1_018_002_203), + ("IxVMPrim.nat_shl_lit", 34_588_777), + ("IxVMPrim.nat_shr_lit", 368_724_780), + ("IxVMPrim.nat_pow_big", 71_440_906), + ("IxVMPrim.nat_beq_lit", 24_004_071), + ("IxVMPrim.nat_ble_lit", 22_333_685), + ("IxVMPrim.nat_dec_le", 195_966_871), + ("IxVMPrim.nat_dec_lt", 199_909_846), + ("IxVMPrim.nat_dec_eq", 81_745_967), + ("IxVMPrim.str_size_lit", 715_819_988), + ("IxVMPrim.bv_to_nat_lit", 570_787_308), -- Mutual block + multi-member recursors - ("IxVMInd.Even", 25_782_173), - ("IxVMInd.Odd", 25_542_593), - ("IxVMInd.Even.rec", 31_350_868), - ("IxVMInd.Odd.rec", 31_349_966), + ("IxVMInd.Even", 25_782_627), + ("IxVMInd.Odd", 25_543_047), + ("IxVMInd.Even.rec", 31_353_084), + ("IxVMInd.Odd.rec", 31_352_181), -- Nested inductive + aux recursor (Tree.mk : List Tree → Tree) ("IxVMInd.Tree", 2_634_029), - ("IxVMInd.Tree.rec", 4_857_081), + ("IxVMInd.Tree.rec", 4_860_101), -- Edge cases from prelude - ("String.Internal.append", 707_266_965), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_063_187_671), + ("String.Internal.append", 707_285_467), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_063_219_586), + -- Aux recursor with transitively-nested inductives (Syntax → Array Syntax + -- → List Syntax); shard 53 regression driver. + ("Lean.Syntax.rec", 734_818_705), ] private def nameOfString (str : String) : Lean.Name := diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index a4aace93..96950f22 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -4818,7 +4818,7 @@ fn aiur_fn_26( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0]; 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_736] = { let __args: [G; IN_736] = [__v_0]; 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_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]; @@ -4976,10 +4976,10 @@ fn aiur_fn_26( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0]; 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_736] = { let __args: [G; IN_736] = [__v_0]; 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_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0]; 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_736] = { let __args: [G; IN_736] = [__v_0]; 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_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]; @@ -6680,7 +6680,7 @@ fn aiur_fn_30( let __v_1: G = G::from_u64(42); let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; 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_743] = { let __args: [G; IN_743] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -6688,13 +6688,13 @@ fn aiur_fn_30( let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = G::from_u64(5); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_729] = { let __args: [G; IN_729] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(10); let __v_13: G = G::from_u64(100); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_12, __v_13, __v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; 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_743] = { let __args: [G; IN_743] = [__v_12, __v_13, __v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -6703,7 +6703,7 @@ fn aiur_fn_30( let __v_21: G = __r_arr[5]; let __v_22: G = G::from_u64(20); let __v_23: G = G::from_u64(200); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; 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_743] = { let __args: [G; IN_743] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = __r_arr[2]; @@ -6712,7 +6712,7 @@ fn aiur_fn_30( let __v_29: G = __r_arr[5]; let __v_30: G = G::from_u64(5); let __v_31: G = G::from_u64(50); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_30, __v_31, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; 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_743] = { let __args: [G; IN_743] = [__v_30, __v_31, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; @@ -6720,19 +6720,19 @@ fn aiur_fn_30( let __v_36: G = __r_arr[4]; let __v_37: G = __r_arr[5]; let __v_38: G = G::from_u64(5); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_729] = { let __args: [G; IN_729] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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(10); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_729] = { let __args: [G; IN_729] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_41: G = __r_arr[0]; let __v_42: G = G::from_u64(20); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_729] = { let __args: [G; IN_729] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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]; let __v_44: G = G::from_u64(10); let __v_45: G = G::from_u64(100); let __v_46: G = G::from_u64(1); let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_44, __v_45, __v_46, __v_47, __v_47, __v_47, __v_47, __v_47]; 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_743] = { let __args: [G; IN_743] = [__v_44, __v_45, __v_46, __v_47, __v_47, __v_47, __v_47, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -6741,7 +6741,7 @@ fn aiur_fn_30( let __v_53: G = __r_arr[5]; let __v_54: G = G::from_u64(10); let __v_55: G = G::from_u64(999); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_54, __v_55, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; 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_743] = { let __args: [G; IN_743] = [__v_54, __v_55, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -6749,13 +6749,13 @@ fn aiur_fn_30( let __v_60: G = __r_arr[4]; let __v_61: G = __r_arr[5]; let __v_62: G = G::from_u64(10); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; 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_729] = { let __args: [G; IN_729] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; 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_63: G = __r_arr[0]; let __v_64: G = G::from_u64(1); let __v_65: G = G::from_u64(10); let __v_66: G = G::from_u64(1); let __v_67: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_64, __v_65, __v_66, __v_67, __v_67, __v_67, __v_67, __v_67]; 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_743] = { let __args: [G; IN_743] = [__v_64, __v_65, __v_66, __v_67, __v_67, __v_67, __v_67, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = __r_arr[2]; @@ -6764,7 +6764,7 @@ fn aiur_fn_30( let __v_73: G = __r_arr[5]; let __v_74: G = G::from_u64(2); let __v_75: G = G::from_u64(20); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_74, __v_75, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; 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_743] = { let __args: [G; IN_743] = [__v_74, __v_75, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __v_78: G = __r_arr[2]; @@ -6773,7 +6773,7 @@ fn aiur_fn_30( let __v_81: G = __r_arr[5]; let __v_82: G = G::from_u64(3); let __v_83: G = G::from_u64(30); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_82, __v_83, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; 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_743] = { let __args: [G; IN_743] = [__v_82, __v_83, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; @@ -6782,7 +6782,7 @@ fn aiur_fn_30( let __v_89: G = __r_arr[5]; let __v_90: G = G::from_u64(4); let __v_91: G = G::from_u64(40); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_90, __v_91, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89]; 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_743] = { let __args: [G; IN_743] = [__v_90, __v_91, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; let __v_93: G = __r_arr[1]; let __v_94: G = __r_arr[2]; @@ -6791,7 +6791,7 @@ fn aiur_fn_30( let __v_97: G = __r_arr[5]; let __v_98: G = G::from_u64(5); let __v_99: G = G::from_u64(50); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_98, __v_99, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; 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_743] = { let __args: [G; IN_743] = [__v_98, __v_99, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __r_arr[2]; @@ -6799,25 +6799,25 @@ fn aiur_fn_30( let __v_104: G = __r_arr[4]; let __v_105: G = __r_arr[5]; let __v_106: G = G::from_u64(1); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_729] = { let __args: [G; IN_729] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_107: G = __r_arr[0]; let __v_108: G = G::from_u64(2); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_729] = { let __args: [G; IN_729] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_109: G = __r_arr[0]; let __v_110: G = G::from_u64(3); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_729] = { let __args: [G; IN_729] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_111: G = __r_arr[0]; let __v_112: G = G::from_u64(4); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_729] = { let __args: [G; IN_729] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_113: G = __r_arr[0]; let __v_114: G = G::from_u64(5); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_729] = { let __args: [G; IN_729] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_115: G = __r_arr[0]; let __v_116: G = G::from_u64(5); let __v_117: G = G::from_u64(50); let __v_118: G = G::from_u64(1); let __v_119: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_116, __v_117, __v_118, __v_119, __v_119, __v_119, __v_119, __v_119]; 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_743] = { let __args: [G; IN_743] = [__v_116, __v_117, __v_118, __v_119, __v_119, __v_119, __v_119, __v_119]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_120: G = __r_arr[0]; let __v_121: G = __r_arr[1]; let __v_122: G = __r_arr[2]; @@ -6826,7 +6826,7 @@ fn aiur_fn_30( let __v_125: G = __r_arr[5]; let __v_126: G = G::from_u64(4); let __v_127: G = G::from_u64(40); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_126, __v_127, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125]; 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_743] = { let __args: [G; IN_743] = [__v_126, __v_127, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_128: G = __r_arr[0]; let __v_129: G = __r_arr[1]; let __v_130: G = __r_arr[2]; @@ -6835,7 +6835,7 @@ fn aiur_fn_30( let __v_133: G = __r_arr[5]; let __v_134: G = G::from_u64(3); let __v_135: G = G::from_u64(30); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_134, __v_135, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133]; 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_743] = { let __args: [G; IN_743] = [__v_134, __v_135, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_136: G = __r_arr[0]; let __v_137: G = __r_arr[1]; let __v_138: G = __r_arr[2]; @@ -6844,7 +6844,7 @@ fn aiur_fn_30( let __v_141: G = __r_arr[5]; let __v_142: G = G::from_u64(2); let __v_143: G = G::from_u64(20); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_142, __v_143, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141]; 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_743] = { let __args: [G; IN_743] = [__v_142, __v_143, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_144: G = __r_arr[0]; let __v_145: G = __r_arr[1]; let __v_146: G = __r_arr[2]; @@ -6853,7 +6853,7 @@ fn aiur_fn_30( let __v_149: G = __r_arr[5]; let __v_150: G = G::from_u64(1); let __v_151: G = G::from_u64(10); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_150, __v_151, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149]; 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_743] = { let __args: [G; IN_743] = [__v_150, __v_151, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_152: G = __r_arr[0]; let __v_153: G = __r_arr[1]; let __v_154: G = __r_arr[2]; @@ -6861,25 +6861,25 @@ fn aiur_fn_30( let __v_156: G = __r_arr[4]; let __v_157: G = __r_arr[5]; let __v_158: G = G::from_u64(1); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_729] = { let __args: [G; IN_729] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_159: G = __r_arr[0]; let __v_160: G = G::from_u64(2); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_729] = { let __args: [G; IN_729] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_161: G = __r_arr[0]; let __v_162: G = G::from_u64(3); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_729] = { let __args: [G; IN_729] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_163: G = __r_arr[0]; let __v_164: G = G::from_u64(4); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_729] = { let __args: [G; IN_729] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_165: G = __r_arr[0]; let __v_166: G = G::from_u64(5); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_729] = { let __args: [G; IN_729] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_167: G = __r_arr[0]; let __v_168: G = G::from_u64(50); let __v_169: G = G::from_u64(500); let __v_170: G = G::from_u64(1); let __v_171: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_168, __v_169, __v_170, __v_171, __v_171, __v_171, __v_171, __v_171]; 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_743] = { let __args: [G; IN_743] = [__v_168, __v_169, __v_170, __v_171, __v_171, __v_171, __v_171, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; let __v_174: G = __r_arr[2]; @@ -6888,7 +6888,7 @@ fn aiur_fn_30( let __v_177: G = __r_arr[5]; let __v_178: G = G::from_u64(30); let __v_179: G = G::from_u64(300); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_178, __v_179, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177]; 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_743] = { let __args: [G; IN_743] = [__v_178, __v_179, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_180: G = __r_arr[0]; let __v_181: G = __r_arr[1]; let __v_182: G = __r_arr[2]; @@ -6897,7 +6897,7 @@ fn aiur_fn_30( let __v_185: G = __r_arr[5]; let __v_186: G = G::from_u64(70); let __v_187: G = G::from_u64(700); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_186, __v_187, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185]; 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_743] = { let __args: [G; IN_743] = [__v_186, __v_187, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; @@ -6906,7 +6906,7 @@ fn aiur_fn_30( let __v_193: G = __r_arr[5]; let __v_194: G = G::from_u64(20); let __v_195: G = G::from_u64(200); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_194, __v_195, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; 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_743] = { let __args: [G; IN_743] = [__v_194, __v_195, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_196: G = __r_arr[0]; let __v_197: G = __r_arr[1]; let __v_198: G = __r_arr[2]; @@ -6915,7 +6915,7 @@ fn aiur_fn_30( let __v_201: G = __r_arr[5]; let __v_202: G = G::from_u64(40); let __v_203: G = G::from_u64(400); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_202, __v_203, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; 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_743] = { let __args: [G; IN_743] = [__v_202, __v_203, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_204: G = __r_arr[0]; let __v_205: G = __r_arr[1]; let __v_206: G = __r_arr[2]; @@ -6924,7 +6924,7 @@ fn aiur_fn_30( let __v_209: G = __r_arr[5]; let __v_210: G = G::from_u64(60); let __v_211: G = G::from_u64(600); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_210, __v_211, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209]; 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_743] = { let __args: [G; IN_743] = [__v_210, __v_211, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_212: G = __r_arr[0]; let __v_213: G = __r_arr[1]; let __v_214: G = __r_arr[2]; @@ -6933,7 +6933,7 @@ fn aiur_fn_30( let __v_217: G = __r_arr[5]; let __v_218: G = G::from_u64(80); let __v_219: G = G::from_u64(800); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_218, __v_219, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217]; 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_743] = { let __args: [G; IN_743] = [__v_218, __v_219, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_220: G = __r_arr[0]; let __v_221: G = __r_arr[1]; let __v_222: G = __r_arr[2]; @@ -6941,25 +6941,25 @@ fn aiur_fn_30( let __v_224: G = __r_arr[4]; let __v_225: G = __r_arr[5]; let __v_226: G = G::from_u64(20); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_729] = { let __args: [G; IN_729] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_227: G = __r_arr[0]; let __v_228: G = G::from_u64(30); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_729] = { let __args: [G; IN_729] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_229: G = __r_arr[0]; let __v_230: G = G::from_u64(40); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_729] = { let __args: [G; IN_729] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_231: G = __r_arr[0]; let __v_232: G = G::from_u64(50); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_729] = { let __args: [G; IN_729] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_233: G = __r_arr[0]; let __v_234: G = G::from_u64(60); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_729] = { let __args: [G; IN_729] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_235: G = __r_arr[0]; let __v_236: G = G::from_u64(70); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_729] = { let __args: [G; IN_729] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_237: G = __r_arr[0]; let __v_238: G = G::from_u64(80); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_729] = { let __args: [G; IN_729] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_239: G = __r_arr[0]; let __ret: [G; OUT_30] = [__v_11, __v_39, __v_41, __v_43, __v_63, __v_107, __v_109, __v_111, __v_113, __v_115, __v_159, __v_161, __v_163, __v_165, __v_167, __v_227, __v_229, __v_231, __v_233, __v_235, __v_237, __v_239]; record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7014,7 +7014,7 @@ fn aiur_fn_31( 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_719] = { let __args: [G; IN_719] = [__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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7035,7 +7035,7 @@ fn aiur_fn_31( 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_719] = { let __args: [G; IN_719] = [__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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -9016,7 +9016,7 @@ fn aiur_fn_55( 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_725] = { let __args: [G; IN_725] = [__v_43]; 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_733] = { let __args: [G; IN_733] = [__v_43]; 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_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -9395,7 +9395,7 @@ fn aiur_fn_60( let __v_59: G = (__v_58 * __v_2); let __v_60: G = (__v_57 + __v_59); let __v_61: G = (__v_0 + __v_60); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_36]; 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_725] = { let __args: [G; IN_725] = [__v_36]; 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_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __v_64: G = __r_arr[2]; @@ -9814,7 +9814,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_712] = { let __args: [G; IN_712] = [__v_0]; 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_720] = { let __args: [G; IN_720] = [__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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9845,7 +9845,7 @@ fn aiur_fn_67( 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_712] = { let __args: [G; IN_712] = [__v_0]; 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_720] = { let __args: [G; IN_720] = [__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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9876,7 +9876,7 @@ fn aiur_fn_68( 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_712] = { let __args: [G; IN_712] = [__v_0]; 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_720] = { let __args: [G; IN_720] = [__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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9964,7 +9964,7 @@ fn aiur_fn_69( let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_732] = { let __args: [G; IN_732] = [__v_1]; 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_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -13434,7 +13434,7 @@ fn aiur_fn_109( 0u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); 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)? } }; @@ -13789,7 +13789,7 @@ fn aiur_fn_113( 0u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_24]; 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_726] = { let __args: [G; IN_726] = [__v_5, __v_24]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_25]; 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)? } }; @@ -13813,7 +13813,7 @@ fn aiur_fn_113( 2u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_24]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __v_5]; 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_26: G = __r_arr[0]; @@ -13827,7 +13827,7 @@ fn aiur_fn_113( 3u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_24]; 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_726] = { let __args: [G; IN_726] = [__v_3, __v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __v_5]; 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_26: G = __r_arr[0]; @@ -13841,7 +13841,7 @@ fn aiur_fn_113( 4u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_24]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_24]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(8); let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; 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)? } }; @@ -13854,7 +13854,7 @@ fn aiur_fn_113( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __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[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_727] = { let __args: [G; IN_727] = [__v_4, __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[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_24: G = __r_arr[0]; let __v_25: G = G::from_u64(7); let __v_26: G = G::from_u64(1); @@ -13865,7 +13865,7 @@ fn aiur_fn_113( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __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[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_727] = { let __args: [G; IN_727] = [__v_4, __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[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_24: G = __r_arr[0]; let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_24]; 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_25: G = __r_arr[0]; @@ -13929,7 +13929,7 @@ fn aiur_fn_113( 11u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_24]; 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_741] = { let __args: [G; IN_741] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_25: 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_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; @@ -15825,7 +15825,7 @@ fn aiur_fn_130( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_37]; 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_739] = { let __args: [G; IN_739] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); let __v_47: G = (__v_45 + __v_46); @@ -16049,7 +16049,7 @@ fn aiur_fn_133( let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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_723] = { let __args: [G; IN_723] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { @@ -16179,7 +16179,7 @@ fn aiur_fn_135( let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; 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_743] = { let __args: [G; IN_743] = [__v_3, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -16337,13 +16337,13 @@ fn aiur_fn_137( }, 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_10]; 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_723] = { let __args: [G; IN_723] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_10]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = []; 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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_743] = { let __args: [G; IN_743] = [__v_8, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; @@ -16444,7 +16444,7 @@ fn aiur_fn_139( let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_9, __v_12, __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_743] = { let __args: [G; IN_743] = [__v_9, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -16494,7 +16494,7 @@ fn aiur_fn_140( let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_723] = { let __args: [G; IN_723] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_140] = [__v_9]; record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -17721,7 +17721,7 @@ fn aiur_fn_149( let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_5, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; 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_723] = { let __args: [G; IN_723] = [__v_5, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { @@ -18104,7 +18104,7 @@ fn aiur_fn_154( let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __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_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_20, __v_17, __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_735] = { let __args: [G; IN_735] = [__v_11, __v_17, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_743] = { let __args: [G; IN_743] = [__v_11, __v_17, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; @@ -18202,7 +18202,7 @@ fn aiur_fn_156( let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; - 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_0]; 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_723] = { let __args: [G; IN_723] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; 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_14: G = __r_arr[0]; let __ret: [G; OUT_156] = [__v_14]; record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18458,7 +18458,7 @@ fn aiur_fn_161( 1u64 => { match __v_4.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_40]; 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_739] = { let __args: [G; IN_739] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_49, __v_1, __v_50]; 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)? } }; @@ -18468,7 +18468,7 @@ fn aiur_fn_161( let __v_54: G = (__v_1 + __v_53); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_48, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_51, __v_55]; 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_721] = { let __args: [G; IN_721] = [__v_51, __v_55]; 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_56: G = __r_arr[0]; let __ret: [G; OUT_161] = [__v_56]; record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18629,7 +18629,7 @@ fn aiur_fn_163( 11u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_18, __v_19]; 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_741] = { let __args: [G; IN_741] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_20: 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_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -19039,7 +19039,7 @@ fn aiur_fn_166( 2u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_75: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_75]; 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_726] = { let __args: [G; IN_726] = [__v_19, __v_75]; 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_76: G = __r_arr[0]; let __ret: [G; OUT_166] = [__v_76]; record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -19461,7 +19461,7 @@ fn aiur_fn_169( 1u64 => { match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_42]; 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_739] = { let __args: [G; IN_739] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(0); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_54, __v_1, __v_55]; 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)? } }; @@ -19575,7 +19575,7 @@ fn aiur_fn_170( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_37]; 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_739] = { let __args: [G; IN_739] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; @@ -19832,7 +19832,7 @@ fn aiur_fn_172( let __v_62: G = (__v_8 + __v_61); let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_59, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_62, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_60, __v_63]; 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_721] = { let __args: [G; IN_721] = [__v_60, __v_63]; 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_64: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_64]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20059,7 +20059,7 @@ fn aiur_fn_175( let __v_74: G = (__v_7 + __v_65); let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_74, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_73, __v_75]; 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_721] = { let __args: [G; IN_721] = [__v_73, __v_75]; 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_76: G = __r_arr[0]; let __ret: [G; OUT_175] = [__v_76]; record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20221,7 +20221,7 @@ fn aiur_fn_176( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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_723] = { let __args: [G; IN_723] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -20332,7 +20332,7 @@ fn aiur_fn_176( let __v_53: G = G::from_u64(0); let __v_54: G = { let __values: [G; 3] = [__v_53, __v_0, __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_55: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_55, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_743] = { let __args: [G; IN_743] = [__v_0, __v_55, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -20435,9 +20435,9 @@ fn aiur_fn_176( let __v_148: G = G::from_u64(1); let __v_149: G = G::from_u64(1); let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_108, __v_150]; 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_721] = { let __args: [G; IN_721] = [__v_108, __v_150]; 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_151: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_151, __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_721] = { let __args: [G; IN_721] = [__v_151, __v_1]; 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_152: 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_152.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_153: G = __loaded[0]; @@ -20468,9 +20468,9 @@ fn aiur_fn_176( let __v_150: G = G::from_u64(1); let __v_151: G = { let __values: [G; 3] = [__v_149, __v_150, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_152: G = { let __values: [G; 3] = [__v_148, __v_113, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_108, __v_152]; 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_721] = { let __args: [G; IN_721] = [__v_108, __v_152]; 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_153: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_153, __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_721] = { let __args: [G; IN_721] = [__v_153, __v_1]; 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_154: 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_154.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_155: G = __loaded[0]; @@ -20997,7 +20997,7 @@ fn aiur_fn_183( let __v_20: G = (__v_19 - __v_3); match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_17, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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_743] = { let __args: [G; IN_743] = [__v_17, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -21112,7 +21112,7 @@ fn aiur_fn_185( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_743] = { let __args: [G; IN_743] = [__v_8, __v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -21167,7 +21167,7 @@ fn aiur_fn_186( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_723] = { let __args: [G; IN_723] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); @@ -21342,7 +21342,7 @@ fn aiur_fn_187( let __v_114: G = __r_arr[0]; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_5, __v_56, __v_2]; 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_115: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_114, __v_115]; 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_734] = { let __args: [G; IN_734] = [__v_114, __v_115]; 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_116: G = __r_arr[0]; let __ret: [G; OUT_187] = [__v_116]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21481,7 +21481,7 @@ fn aiur_fn_189( 1u64 => { match __v_5.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_41]; 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_739] = { let __args: [G; IN_739] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_189] = [__v_51]; record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21798,9 +21798,9 @@ fn aiur_fn_194( 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_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_25, __v_74]; 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_721] = { let __args: [G; IN_721] = [__v_25, __v_74]; 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_76: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_73, __v_75]; 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_721] = { let __args: [G; IN_721] = [__v_73, __v_75]; 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_77: G = __r_arr[0]; let __ret: [G; OUT_194] = [__v_76, __v_77]; record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -22231,7 +22231,7 @@ fn aiur_fn_199( let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_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_718] = { let __args: [G; IN_718] = [__v_6, __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_7: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_5, __v_7]; record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24798,7 +24798,7 @@ fn aiur_fn_230( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_5: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_5]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -29993,7 +29993,7 @@ fn aiur_fn_320( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__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[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_744] = { let __args: [G; IN_744] = [__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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_29]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -30049,7 +30049,7 @@ fn aiur_fn_320( 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_736] = { let __args: [G; IN_736] = [__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[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_744] = { let __args: [G; IN_744] = [__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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__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[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_70: G = __r_arr[0]; @@ -31021,7 +31021,7 @@ fn aiur_fn_339( } }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -31092,7 +31092,7 @@ fn aiur_fn_340( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; 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_8: G = __r_arr[0]; @@ -31444,7 +31444,7 @@ fn aiur_fn_343( }, 0u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_12]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0]; @@ -31454,7 +31454,7 @@ fn aiur_fn_343( match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; 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_741] = { let __args: [G; IN_741] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_16]; 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)? } }; @@ -31502,7 +31502,7 @@ fn aiur_fn_343( }, 0u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_12]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0]; @@ -31512,7 +31512,7 @@ fn aiur_fn_343( match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; 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_741] = { let __args: [G; IN_741] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_16]; 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)? } }; @@ -31593,12 +31593,12 @@ fn aiur_fn_344( }, 0u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_8]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_3, __v_4, __v_5]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_11]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_11]; 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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_12, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0]; @@ -31618,7 +31618,7 @@ fn aiur_fn_344( match __v_18.as_canonical_u64() { 1u64 => { let __v_20: G = G::from_u64(2); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_20]; 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_741] = { let __args: [G; IN_741] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_19, __v_21]; 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)? } }; @@ -32184,10 +32184,10 @@ fn aiur_fn_348( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; 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_726] = { let __args: [G; IN_726] = [__v_0, __v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0]; @@ -32309,7 +32309,7 @@ fn aiur_fn_349( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -32325,10 +32325,10 @@ fn aiur_fn_349( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_17]; 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_726] = { let __args: [G; IN_726] = [__v_3, __v_17]; 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_18: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_14, __v_16, __v_18]; record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -32423,7 +32423,7 @@ fn aiur_fn_349( }, 0u64 => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_48]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; @@ -32435,7 +32435,7 @@ fn aiur_fn_349( let __v_55: G = __loaded[3]; match __v_52.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_53]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_53]; 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_56: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; @@ -32465,10 +32465,10 @@ fn aiur_fn_349( 0u64 => { let __v_62: G = G::from_u64(1); let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_51, __v_63]; 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_726] = { let __args: [G; IN_726] = [__v_51, __v_63]; 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_64: G = __r_arr[0]; let __v_65: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_65]; 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_726] = { let __args: [G; IN_726] = [__v_3, __v_65]; 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_66: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_62, __v_64, __v_66]; record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -32575,13 +32575,13 @@ fn aiur_fn_350( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; 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_726] = { let __args: [G; IN_726] = [__v_0, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_11]; 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_726] = { let __args: [G; IN_726] = [__v_0, __v_11]; 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 __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_8, __v_10, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; @@ -32834,7 +32834,7 @@ fn aiur_fn_353( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -32846,7 +32846,7 @@ fn aiur_fn_353( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_12]; 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_726] = { let __args: [G; IN_726] = [__v_3, __v_12]; 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_15: G = __r_arr[0]; let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; 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_16: G = __r_arr[0]; @@ -32881,7 +32881,7 @@ fn aiur_fn_353( }, 0u64 => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_21]; 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_726] = { let __args: [G; IN_726] = [__v_10, __v_21]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; @@ -32893,7 +32893,7 @@ fn aiur_fn_353( let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_26]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; @@ -32928,13 +32928,13 @@ fn aiur_fn_353( }, 0u64 => { let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_24, __v_35]; 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_726] = { let __args: [G; IN_726] = [__v_24, __v_35]; 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_36: G = __r_arr[0]; let __v_37: G = G::from_u64(2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_37]; 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_726] = { let __args: [G; IN_726] = [__v_10, __v_37]; 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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(3); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_39]; 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_726] = { let __args: [G; IN_726] = [__v_10, __v_39]; 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_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); @@ -33112,7 +33112,7 @@ fn aiur_fn_354( }, 0u64 => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_21]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_21]; 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_22: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_22, __v_2, __v_3, __v_4]; 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_23: G = __r_arr[0]; @@ -33262,7 +33262,7 @@ fn aiur_fn_357( }, 0u64 => { let __v_5: G = G::from_u64(2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -33274,7 +33274,7 @@ fn aiur_fn_357( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_10]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; 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_14: G = __r_arr[0]; @@ -33352,7 +33352,7 @@ fn aiur_fn_358( }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __v_5]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -33364,7 +33364,7 @@ fn aiur_fn_358( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_10]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -33434,7 +33434,7 @@ fn aiur_fn_359( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; 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]; @@ -33656,7 +33656,7 @@ fn aiur_fn_362( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_7]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; 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)? } }; let __v_11: G = __r_arr[0]; @@ -33844,10 +33844,10 @@ fn aiur_fn_364( }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_9]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_11]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_11]; 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 __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_10, __v_5]; 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_13: G = __r_arr[0]; @@ -33951,7 +33951,7 @@ fn aiur_fn_365( let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_25, __v_19, __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 = G::from_u64(2); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2, __v_29]; 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_741] = { let __args: [G; IN_741] = [__v_2, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_28, __v_30]; 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)? } }; @@ -34032,10 +34032,10 @@ fn aiur_fn_366( match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_9]; 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_726] = { let __args: [G; IN_726] = [__v_5, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_11]; 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_726] = { let __args: [G; IN_726] = [__v_5, __v_11]; 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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_6, __v_7, __v_8]; 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_13: G = __r_arr[0]; @@ -34096,7 +34096,7 @@ fn aiur_fn_366( let __v_39: G = G::from_u64(0); let __v_40: G = { let __values: [G; 4] = [__v_38, __v_37, __v_12, __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(2); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_5, __v_41]; 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_741] = { let __args: [G; IN_741] = [__v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_40, __v_42]; 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_43: G = __r_arr[0]; @@ -34149,10 +34149,10 @@ fn aiur_fn_367( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_8]; 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_726] = { let __args: [G; IN_726] = [__v_4, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __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_726] = { let __args: [G; IN_726] = [__v_4, __v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5, __v_6, __v_7]; 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_12: G = __r_arr[0]; @@ -34527,7 +34527,7 @@ fn aiur_fn_369( let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_12, __v_2, __v_3, __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(2); - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_4, __v_15]; 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_738] = { let __args: [G; IN_738] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_14, __v_16]; 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_17: G = __r_arr[0]; @@ -34555,7 +34555,7 @@ fn aiur_fn_369( }, 0u64 => { let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_21, __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_726] = { let __args: [G; IN_726] = [__v_21, __v_25]; 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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); let __v_28: G = G::from_u64(1); @@ -34570,7 +34570,7 @@ fn aiur_fn_369( let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 4] = [__v_36, __v_35, __v_1, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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(2); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_4, __v_39]; 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_741] = { let __args: [G; IN_741] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_38, __v_40]; 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)? } }; @@ -34621,7 +34621,7 @@ fn aiur_fn_370( }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_6]; 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_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]; @@ -34638,7 +34638,7 @@ fn aiur_fn_370( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - 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_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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -35479,7 +35479,7 @@ fn aiur_fn_381( 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_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __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_3: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -35519,11 +35519,11 @@ fn aiur_fn_381( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_20]; 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_23: G = __r_arr[0]; let __v_24: G = G::from_u64(8); let __v_25: G = { let __values: [G; 4] = [__v_24, __v_18, __v_19, __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_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; 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_741] = { let __args: [G; IN_741] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_25, __v_26]; 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)? } }; @@ -35578,7 +35578,7 @@ fn aiur_fn_382( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __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_726] = { let __args: [G; IN_726] = [__v_4, __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_5: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; 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_6: G = __r_arr[0]; @@ -35605,7 +35605,7 @@ fn aiur_fn_382( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_9]; 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_726] = { let __args: [G; IN_726] = [__v_4, __v_9]; 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 __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; @@ -35640,19 +35640,19 @@ fn aiur_fn_382( }, 0u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_20]; 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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_22]; 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_23: G = __r_arr[0]; let __v_24: G = G::from_u64(3); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_24]; 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_726] = { let __args: [G; IN_726] = [__v_3, __v_24]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(4); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_26]; 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_27: 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_28: G = __loaded[0]; @@ -35721,7 +35721,7 @@ fn aiur_fn_382( let __v_79: G = G::from_u64(0); let __v_80: G = { let __values: [G; 4] = [__v_78, __v_77, __v_27, __v_79]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(5); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_3, __v_81]; 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_741] = { let __args: [G; IN_741] = [__v_3, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = G::from_u64(1); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_80, __v_82]; 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)? } }; @@ -36219,7 +36219,7 @@ fn aiur_fn_391( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __v_2]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__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]; @@ -36275,7 +36275,7 @@ fn aiur_fn_392( 1u64 => { let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_1]; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_0, __v_4]; 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_738] = { let __args: [G; IN_738] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_392] = [__v_5]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36724,7 +36724,7 @@ fn aiur_fn_398( match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_8, __v_2, __v_9]; 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)? } }; @@ -37003,7 +37003,7 @@ fn aiur_fn_402( }, 1u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_12]; 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_726] = { let __args: [G; IN_726] = [__v_9, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_13, __v_14]; 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)? } }; @@ -37053,7 +37053,7 @@ fn aiur_fn_403( let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_10, __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_721] = { let __args: [G; IN_721] = [__v_10, __v_1]; 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 __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0]; @@ -37144,7 +37144,7 @@ fn aiur_fn_404( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_13]; 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_726] = { let __args: [G; IN_726] = [__v_5, __v_13]; 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_16: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -37220,7 +37220,7 @@ fn aiur_fn_405( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __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_726] = { let __args: [G; IN_726] = [__v_4, __v_6]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -37253,12 +37253,12 @@ fn aiur_fn_405( match __v_18.as_canonical_u64() { 2u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_19]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_19]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_2, __v_3, __v_4]; 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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_22]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; @@ -37490,9 +37490,9 @@ fn aiur_fn_407( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __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_726] = { let __args: [G; IN_726] = [__v_6, __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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __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_726] = { let __args: [G; IN_726] = [__v_5, __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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -37763,7 +37763,7 @@ fn aiur_fn_410( let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_10, __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_721] = { let __args: [G; IN_721] = [__v_10, __v_1]; 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 __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0]; @@ -37847,7 +37847,7 @@ fn aiur_fn_411( }, 1u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_12]; 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_726] = { let __args: [G; IN_726] = [__v_9, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_13, __v_14]; 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)? } }; @@ -37913,7 +37913,7 @@ fn aiur_fn_412( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_13]; 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_726] = { let __args: [G; IN_726] = [__v_5, __v_13]; 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_16: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -37984,9 +37984,9 @@ fn aiur_fn_413( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __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_726] = { let __args: [G; IN_726] = [__v_6, __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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __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_726] = { let __args: [G; IN_726] = [__v_5, __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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38368,7 +38368,7 @@ fn aiur_fn_418( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -38392,10 +38392,10 @@ fn aiur_fn_418( match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_13]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_15]; 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_16: 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_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -38614,7 +38614,7 @@ fn aiur_fn_420( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_5]; 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_13: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 1u64 => { @@ -38662,7 +38662,7 @@ fn aiur_fn_420( let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_23]; 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_726] = { let __args: [G; IN_726] = [__v_9, __v_23]; 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_26: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -38678,7 +38678,7 @@ fn aiur_fn_420( let __v_37: G = __loaded[10]; match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__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 __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_38.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_39.as_canonical_u64() { @@ -38708,7 +38708,7 @@ fn aiur_fn_420( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_6, __v_31]; 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_737] = { let __args: [G; IN_737] = [__v_6, __v_31]; 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_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; @@ -38716,14 +38716,14 @@ fn aiur_fn_420( _ => { let __v_45: G = (__v_3 + __v_4); let __v_46: G = (__v_2 + __v_45); - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_1, __v_46]; 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_738] = { let __args: [G; IN_738] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = (__v_40 - __v_33); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_21, __v_48]; 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_741] = { let __args: [G; IN_741] = [__v_21, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_5 + __v_50); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_51]; 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_741] = { let __args: [G; IN_741] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_44, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; @@ -38809,7 +38809,7 @@ fn aiur_fn_421( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_5, __v_6, __v_7]; 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_11: G = __r_arr[0]; @@ -38831,7 +38831,7 @@ fn aiur_fn_421( let __v_14: G = (__v_1 + __v_2); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 + __v_15); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __v_16]; 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_17: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_17, __v_5, __v_6, __v_7]; 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_18: G = __r_arr[0]; @@ -38849,13 +38849,13 @@ fn aiur_fn_421( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __v_14]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_5, __v_6, __v_7]; 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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_4 + __v_22); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_23]; 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_741] = { let __args: [G; IN_741] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_21, __v_7]; 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_25: G = __r_arr[0]; @@ -38993,7 +38993,7 @@ fn aiur_fn_422( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_13]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_13]; 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_16: G = __r_arr[0]; let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; 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_17: G = __r_arr[0]; @@ -39014,7 +39014,7 @@ fn aiur_fn_422( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __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_726] = { let __args: [G; IN_726] = [__v_11, __v_22]; 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_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_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -39095,18 +39095,18 @@ fn aiur_fn_423( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; 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_742] = { let __args: [G; IN_742] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_5, __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_737] = { let __args: [G; IN_737] = [__v_5, __v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_12]; 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_726] = { let __args: [G; IN_726] = [__v_8, __v_12]; 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_15: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -39122,7 +39122,7 @@ fn aiur_fn_423( let __v_26: G = __loaded[10]; match __v_16.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_19]; 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_726] = { let __args: [G; IN_726] = [__v_8, __v_19]; 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_27: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; @@ -39146,7 +39146,7 @@ fn aiur_fn_423( 0u64 => { match __v_34.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __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_40: G = __r_arr[0]; let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_40, __v_7, __v_8, __v_9]; 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_41: G = __r_arr[0]; @@ -39168,7 +39168,7 @@ fn aiur_fn_423( let __v_43: G = __r_arr[0]; let __v_44: G = (__v_1 + __v_2); let __v_45: G = (__v_44 + __v_3); - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_0, __v_45]; 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_738] = { let __args: [G; IN_738] = [__v_0, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_43, __v_46]; 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]; @@ -39177,7 +39177,7 @@ fn aiur_fn_423( let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_4 + __v_50); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_51]; 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_741] = { let __args: [G; IN_741] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_49, __v_52]; 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_53: G = __r_arr[0]; @@ -39330,10 +39330,10 @@ fn aiur_fn_425( }, 0u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; 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_726] = { let __args: [G; IN_726] = [__v_0, __v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_10, __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_11: G = __r_arr[0]; @@ -39341,7 +39341,7 @@ fn aiur_fn_425( match __v_11.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_13]; 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_741] = { let __args: [G; IN_741] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(0); @@ -39406,10 +39406,10 @@ fn aiur_fn_426( }, 0u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(4); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; 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_726] = { let __args: [G; IN_726] = [__v_0, __v_9]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_10, __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_11: G = __r_arr[0]; @@ -39417,7 +39417,7 @@ fn aiur_fn_426( match __v_11.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_13]; 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_741] = { let __args: [G; IN_741] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(0); @@ -39477,7 +39477,7 @@ fn aiur_fn_427( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_8]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_8]; 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_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -39502,7 +39502,7 @@ fn aiur_fn_427( match __v_25.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __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_726] = { let __args: [G; IN_726] = [__v_6, __v_26]; 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_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __ret: [G; OUT_427] = [__v_28, __v_27]; @@ -39635,7 +39635,7 @@ fn aiur_fn_429( 0u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __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_726] = { let __args: [G; IN_726] = [__v_4, __v_7]; 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_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -39651,7 +39651,7 @@ fn aiur_fn_429( let __v_22: G = __loaded[10]; match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __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_726] = { let __args: [G; IN_726] = [__v_4, __v_15]; 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_23: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -39682,7 +39682,7 @@ fn aiur_fn_429( }, _ => { let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_29, __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_726] = { let __args: [G; IN_726] = [__v_29, __v_36]; 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_37: G = __r_arr[0]; let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_3, __v_4, __v_5]; 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_38: G = __r_arr[0]; @@ -39704,7 +39704,7 @@ fn aiur_fn_429( let __v_47: G = G::from_u64(2); let __v_48: G = G::from_u64(0); let __v_49: G = { let __values: [G; 4] = [__v_47, __v_37, __v_44, __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 __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_41, __v_1]; 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_738] = { let __args: [G; IN_738] = [__v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_49, __v_50]; 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_51: G = __r_arr[0]; @@ -40033,7 +40033,7 @@ fn aiur_fn_435( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __v_5]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -40159,7 +40159,7 @@ fn aiur_fn_435( if (__v_13 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); } - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_13]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_13]; 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_16: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -40185,9 +40185,9 @@ fn aiur_fn_435( let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_19, __v_14, __v_30, __v_1, __v_2, __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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22, __v_32]; 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_726] = { let __args: [G; IN_726] = [__v_22, __v_32]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_33]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_33]; 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_34: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; @@ -40461,7 +40461,7 @@ fn aiur_fn_440( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __v_5]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -40604,7 +40604,7 @@ fn aiur_fn_440( if (__v_13 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); } - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_13]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_13]; 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_16: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -40630,9 +40630,9 @@ fn aiur_fn_440( let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_19, __v_14, __v_30, __v_1, __v_2, __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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22, __v_32]; 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_726] = { let __args: [G; IN_726] = [__v_22, __v_32]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_33]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_33]; 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_34: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; @@ -41815,7 +41815,7 @@ fn aiur_fn_459( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -41844,9 +41844,9 @@ fn aiur_fn_459( match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_21]; 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_726] = { let __args: [G; IN_726] = [__v_14, __v_21]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_22]; 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_23: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -42054,7 +42054,7 @@ fn aiur_fn_462( } }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -42124,7 +42124,7 @@ fn aiur_fn_463( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_7]; 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_10: G = __r_arr[0]; let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; 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]; @@ -42165,7 +42165,7 @@ fn aiur_fn_463( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_11]; 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_726] = { let __args: [G; IN_726] = [__v_1, __v_11]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; @@ -42381,7 +42381,7 @@ fn aiur_fn_465( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_8]; 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_726] = { let __args: [G; IN_726] = [__v_3, __v_8]; 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_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -42403,7 +42403,7 @@ fn aiur_fn_465( let __v_25: G = (__v_23 - __v_24); match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_15]; 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_26: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -42513,7 +42513,7 @@ fn aiur_fn_466( let __v_10: G = G::from_u64(8); let __v_11: G = { let __values: [G; 4] = [__v_10, __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_12: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_12]; 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_726] = { let __args: [G; IN_726] = [__v_4, __v_12]; 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_13: G = __r_arr[0]; let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_11, __v_13, __v_6, __v_7, __v_8]; 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_14: G = __r_arr[0]; @@ -43263,7 +43263,7 @@ fn aiur_fn_472( 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_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __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_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -43312,7 +43312,7 @@ fn aiur_fn_473( 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_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __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_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -43364,7 +43364,7 @@ fn aiur_fn_474( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -44711,7 +44711,7 @@ fn aiur_fn_496( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_14]; 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_18: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; @@ -44727,7 +44727,7 @@ fn aiur_fn_496( let __v_29: G = __loaded[10]; match __v_19.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_12, __v_22]; 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_741] = { let __args: [G; IN_741] = [__v_12, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_30, __v_1]; 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_31: G = __r_arr[0]; @@ -44851,7 +44851,7 @@ fn aiur_fn_498( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_5]; 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_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -45344,7 +45344,7 @@ fn aiur_fn_504( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -45537,9 +45537,9 @@ fn aiur_fn_506( }, 1u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_6]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __v_7]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -46063,7 +46063,7 @@ fn aiur_fn_515( 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_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __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_6: G = __r_arr[0]; let __ret: [G; OUT_515] = [__v_6]; record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46134,7 +46134,7 @@ fn aiur_fn_517( 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_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __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_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -46250,7 +46250,7 @@ fn aiur_fn_519( 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_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_6, __v_1, __v_7]; 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)? } }; @@ -46491,8 +46491,8 @@ fn aiur_fn_524( }) } -const INPUT_SIZE_525: usize = 14; -const IN_525: usize = 14; +const INPUT_SIZE_525: usize = 15; +const IN_525: usize = 15; const OUT_525: usize = 1; fn aiur_fn_525( inp: [G; IN_525], @@ -46515,82 +46515,83 @@ fn aiur_fn_525( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; + let __v_14: G = inp[14]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; - let __v_14: G = __r_arr[0]; - let __v_15: G = (__v_9 + __v_10); - let __v_16: G = (__v_8 + __v_15); - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_12]; 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_17: G = __r_arr[0]; - let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_14, __v_17, __v_16, __v_3, __v_4, __v_18]; 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_19: G = __r_arr[0]; - let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_6, __v_0, __v_20]; 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 __v_21: G = __r_arr[0]; - let __v_22: G = __r_arr[1]; - let __v_23: G = G::from_u64(1); + let __v_15: G = __r_arr[0]; + let __v_16: G = (__v_10 + __v_11); + let __v_17: G = (__v_9 + __v_16); + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_13]; 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_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_15, __v_18, __v_17, __v_3, __v_4, __v_19]; 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_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_7, __v_0, __v_21]; 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_22: G = __r_arr[0]; + let __v_23: G = __r_arr[1]; let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_26: G = 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_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_29: 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_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_32: 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_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_35: G = G::from_u64(0); - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_19, __v_6, __v_25, __v_28, __v_31, __v_34, __v_12, __v_13, __v_35]; 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_36: G = __r_arr[0]; - let __v_37: G = __r_arr[1]; - let __v_38: G = __r_arr[2]; - let __v_39: G = __r_arr[3]; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; - let __v_40: G = __r_arr[0]; + let __v_34: G = G::from_u64(1); + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(0); + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_20, __v_6, __v_26, __v_29, __v_32, __v_35, __v_13, __v_14, __v_36]; 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_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __v_42: G = (__v_40 + __v_41); - let __v_43: G = (__v_16 + __v_42); - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; - let __v_44: G = __r_arr[0]; - let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_45, __v_17]; 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_46: G = __r_arr[0]; - let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_46, __v_41, __v_47]; 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_48: G = __r_arr[0]; - let __v_49: G = G::from_u64(1); - let __v_50: G = (__v_43 - __v_49); - let __v_51: G = (__v_11 + __v_22); - let __v_52: G = (__v_50 - __v_51); - let __v_53: G = G::from_u64(0); + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = (__v_41 + __v_42); + let __v_44: G = (__v_17 + __v_43); + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_46, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_47, __v_42, __v_48]; 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 __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(1); + let __v_51: G = (__v_44 - __v_50); + let __v_52: G = (__v_12 + __v_23); + let __v_53: G = (__v_51 - __v_52); let __v_54: G = G::from_u64(0); - let __v_55: G = { let __values: [G; 4] = [__v_53, __v_52, __v_54, __v_54]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_55, __v_48]; 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_56: G = __r_arr[0]; - 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_1, __v_5, __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 __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_59, __v_17, __v_8, __v_43, __v_3, __v_4]; 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_60: G = __r_arr[0]; - let __v_61: G = G::from_u64(0); - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_60, __v_40, __v_42, __v_61]; 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 __v_62: G = __r_arr[0]; - 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_56, __v_62, __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(1); + let __v_55: G = G::from_u64(0); + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_56, __v_49]; 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_57: G = __r_arr[0]; + let __v_58: G = G::from_u64(2); + let __v_59: G = G::from_u64(0); + let __v_60: G = { let __values: [G; 4] = [__v_58, __v_1, __v_5, __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 __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_60, __v_18, __v_9, __v_44, __v_3, __v_4]; 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_61: G = __r_arr[0]; + let __v_62: G = G::from_u64(0); + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_61, __v_41, __v_43, __v_62]; 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_63: G = __r_arr[0]; + 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_57, __v_63, __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(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_69: G = G::from_u64(0); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_37, __v_38, __v_36, __v_7, __v_11, __v_40, __v_16, __v_68, __v_12, __v_13, __v_69]; 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_70: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_65, __v_70]; 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_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_70: G = G::from_u64(0); + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_38, __v_39, __v_37, __v_8, __v_12, __v_41, __v_17, __v_69, __v_13, __v_14, __v_70]; 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_71: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_71, __v_36]; 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_524] = { let __args: [G; IN_524] = [__v_66, __v_71]; 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_72: G = __r_arr[0]; - let __ret: [G; OUT_525] = [__v_72]; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_72, __v_37]; 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_73: G = __r_arr[0]; + let __ret: [G; OUT_525] = [__v_73]; record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) @@ -46617,7 +46618,7 @@ fn aiur_fn_526( 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_537] = { let __args: [G; IN_537] = [__v_0, __v_2, __v_7, __v_8]; 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_539] = { let __args: [G; IN_539] = [__v_0, __v_2, __v_7, __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 __ret: [G; OUT_526] = [__v_9]; record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46755,11 +46756,11 @@ fn aiur_fn_528( } }, _ => { - 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_724] = { let __args: [G; IN_724] = [__v_2]; 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_13: 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_724] = { let __args: [G; IN_724] = [__v_3]; 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_14: 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_724] = { let __args: [G; IN_724] = [__v_4]; 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_15: G = __r_arr[0]; let __ret: [G; OUT_528] = [__v_13, __v_14, __v_15, __v_0]; record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46781,7 +46782,7 @@ fn aiur_fn_529( 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_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __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_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -46970,7 +46971,7 @@ fn aiur_fn_531( 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_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __v_1]; 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_3: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -47029,7 +47030,7 @@ fn aiur_fn_531( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __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_49: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_50: G = __loaded[0]; @@ -47089,12 +47090,12 @@ fn aiur_fn_532( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0]; 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_536] = { let __args: [G; IN_536] = [__v_0]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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_724] = { let __args: [G; IN_724] = [__v_5]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_7, __v_2]; 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_721] = { let __args: [G; IN_721] = [__v_7, __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_8: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_8, __v_3, __v_4]; 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]; @@ -47109,7 +47110,7 @@ fn aiur_fn_532( match __v_12.as_canonical_u64() { 2u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_13, __v_16]; 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_1, __v_13, __v_11, __v_16]; 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 __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_532] = [__v_17, __v_18]; @@ -47127,8 +47128,8 @@ fn aiur_fn_532( }) } -const INPUT_SIZE_533: usize = 3; -const IN_533: usize = 3; +const INPUT_SIZE_533: usize = 4; +const IN_533: usize = 4; const OUT_533: usize = 2; fn aiur_fn_533( inp: [G; IN_533], @@ -47136,6 +47137,145 @@ fn aiur_fn_533( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> 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]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + let __v_9: G = __loaded[5]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_533] = [__v_10, __v_11]; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = (__v_5 - __v_1); + match __v_10.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_7]; 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_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_533] = [__v_12, __v_3]; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_3 + __v_12); + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_1, __v_2, __v_13]; 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 __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_533] = [__v_14, __v_15]; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_3 + __v_11); + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_1, __v_2, __v_12]; 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 __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_533] = [__v_13, __v_14]; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_534: usize = 2; +const IN_534: usize = 2; +const OUT_534: usize = 1; +fn aiur_fn_534( + inp: [G; IN_534], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_534] = [__v_5]; + record.function_queries[534].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_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_534] = [__v_8]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_6, __v_3]; 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 __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_7, __v_4]; 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_9: G = __r_arr[0]; + let __ret: [G; OUT_534] = [__v_9]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_534] = [__v_9]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_535: usize = 3; +const IN_535: usize = 3; +const OUT_535: usize = 2; +fn aiur_fn_535( + inp: [G; IN_535], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; @@ -47148,8 +47288,8 @@ fn aiur_fn_533( 1u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_533] = [__v_6, __v_7]; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_535] = [__v_6, __v_7]; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -47157,18 +47297,18 @@ fn aiur_fn_533( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_533] = [__v_7, __v_2]; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_535] = [__v_7, __v_2]; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_5, __v_1, __v_8]; 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_535] = { let __args: [G; IN_535] = [__v_5, __v_1, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_533] = [__v_9, __v_10]; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_535] = [__v_9, __v_10]; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47180,40 +47320,40 @@ fn aiur_fn_533( }) } -const INPUT_SIZE_534: usize = 1; -const IN_534: usize = 1; -const OUT_534: usize = 2; -fn aiur_fn_534( - inp: [G; IN_534], +const INPUT_SIZE_536: usize = 1; +const IN_536: usize = 1; +const OUT_536: usize = 2; +fn aiur_fn_536( + inp: [G; IN_536], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_534], ExecError> { +) -> Result<[G; OUT_536], 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_535] = { let __args: [G; IN_535] = [__v_0, __v_3]; 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_537] = { let __args: [G; IN_537] = [__v_0, __v_3]; 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_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_724] = { let __args: [G; IN_724] = [__v_4]; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_534] = [__v_6, __v_5]; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_536] = [__v_6, __v_5]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_535: usize = 2; -const IN_535: usize = 2; -const OUT_535: usize = 2; -fn aiur_fn_535( - inp: [G; IN_535], +const INPUT_SIZE_537: usize = 2; +const IN_537: usize = 2; +const OUT_537: usize = 2; +fn aiur_fn_537( + inp: [G; IN_537], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_535], 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]; @@ -47226,31 +47366,31 @@ fn aiur_fn_535( 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_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !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_537] = { let __args: [G; IN_537] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_535] = [__v_8, __v_9]; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_537] = [__v_8, __v_9]; + record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_535] = [__v_1, __v_0]; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_537] = [__v_1, __v_0]; + record.function_queries[537].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_538: usize = 3; +const IN_538: usize = 3; +const OUT_538: usize = 1; +fn aiur_fn_538( + inp: [G; IN_538], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_536], 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]; @@ -47264,19 +47404,19 @@ fn aiur_fn_536( 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_536] = [__v_8]; - record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_538] = [__v_8]; + record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_1, __v_2]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_5, __v_1, __v_2]; 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_538] = { let __args: [G; IN_538] = [__v_5, __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 __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_536] = [__v_9]; - record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_538] = [__v_9]; + record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47286,15 +47426,15 @@ fn aiur_fn_536( }) } -const INPUT_SIZE_537: usize = 4; -const IN_537: usize = 4; -const OUT_537: usize = 1; -fn aiur_fn_537( - inp: [G; IN_537], +const INPUT_SIZE_539: usize = 4; +const IN_539: usize = 4; +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_537], 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]; @@ -47303,8 +47443,8 @@ fn aiur_fn_537( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_537] = [__v_0]; - record.function_queries[537].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)); return Ok(__ret); }, _ => { @@ -47317,25 +47457,25 @@ fn aiur_fn_537( 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_537] = { let __args: [G; IN_537] = [__v_11, __v_1, __v_2, __v_13]; 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_539] = { let __args: [G; IN_539] = [__v_11, __v_1, __v_2, __v_13]; 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 __ret: [G; OUT_537] = [__v_14]; - record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_539] = [__v_14]; + record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_538: usize = 4; -const IN_538: usize = 4; -const OUT_538: usize = 1; -fn aiur_fn_538( - inp: [G; IN_538], +const INPUT_SIZE_540: usize = 4; +const IN_540: usize = 4; +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_538], 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]; @@ -47344,8 +47484,8 @@ fn aiur_fn_538( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_538] = [__v_0]; - record.function_queries[538].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); }, _ => { @@ -47360,59 +47500,59 @@ fn aiur_fn_538( 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_538] = { let __args: [G; IN_538] = [__v_13, __v_1, __v_2, __v_15]; 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_540] = { let __args: [G; IN_540] = [__v_13, __v_1, __v_2, __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 = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_16]; - record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_540] = [__v_16]; + record.function_queries[540].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 = 2; -fn aiur_fn_539( - inp: [G; IN_539], +const INPUT_SIZE_541: usize = 2; +const IN_541: usize = 2; +const OUT_541: usize = 2; +fn aiur_fn_541( + inp: [G; IN_541], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_539], 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 = 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_540] = { let __args: [G; IN_540] = [__v_0, __v_1, __v_4]; 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_542] = { let __args: [G; IN_542] = [__v_0, __v_1, __v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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_724] = { let __args: [G; IN_724] = [__v_5]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_539] = [__v_7, __v_6]; - record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_541] = [__v_7, __v_6]; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_540: usize = 3; -const IN_540: usize = 3; -const OUT_540: usize = 2; -fn aiur_fn_540( - inp: [G; IN_540], +const INPUT_SIZE_542: usize = 3; +const IN_542: usize = 3; +const OUT_542: usize = 2; +fn aiur_fn_542( + inp: [G; IN_542], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_540], ExecError> { +) -> Result<[G; OUT_542], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_540] = [__v_2, __v_0]; - record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_542] = [__v_2, __v_0]; + record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47427,11 +47567,11 @@ fn aiur_fn_540( let __v_8: G = (__v_1 - __v_7); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __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_540] = { let __args: [G; IN_540] = [__v_5, __v_8, __v_10]; 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_542] = { let __args: [G; IN_542] = [__v_5, __v_8, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_540] = [__v_11, __v_12]; - record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_542] = [__v_11, __v_12]; + record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47443,15 +47583,15 @@ fn aiur_fn_540( }) } -const INPUT_SIZE_541: usize = 3; -const IN_541: usize = 3; -const OUT_541: usize = 1; -fn aiur_fn_541( - inp: [G; IN_541], +const INPUT_SIZE_543: usize = 3; +const IN_543: usize = 3; +const OUT_543: usize = 1; +fn aiur_fn_543( + inp: [G; IN_543], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_541], 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]; @@ -47459,8 +47599,8 @@ fn aiur_fn_541( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_541] = [__v_0]; - record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_543] = [__v_0]; + record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47473,25 +47613,25 @@ fn aiur_fn_541( 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_541] = { let __args: [G; IN_541] = [__v_10, __v_1, __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_543] = { let __args: [G; IN_543] = [__v_10, __v_1, __v_12]; 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_13: G = __r_arr[0]; - let __ret: [G; OUT_541] = [__v_13]; - record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_543] = [__v_13]; + record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_542: usize = 13; -const IN_542: usize = 13; -const OUT_542: usize = 1; -fn aiur_fn_542( - inp: [G; IN_542], +const INPUT_SIZE_544: usize = 14; +const IN_544: usize = 14; +const OUT_544: usize = 1; +fn aiur_fn_544( + inp: [G; IN_544], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_542], 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]; @@ -47506,69 +47646,70 @@ fn aiur_fn_542( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; + let __v_13: G = inp[13]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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 __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + match __v_14.as_canonical_u64() { 1u64 => { - 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_542] = [__v_18]; - record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_18: G = G::from_u64(1); + let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_544] = [__v_19]; + record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; - let __v_17: G = __loaded[0]; - let __v_18: G = __loaded[1]; - let __v_19: G = __loaded[2]; - let __v_20: G = __loaded[3]; - let __v_21: G = __loaded[4]; - let __v_22: G = __loaded[5]; - let __v_23: G = __loaded[6]; - let __v_24: G = __loaded[7]; - let __v_25: G = __loaded[8]; - let __v_26: G = __loaded[9]; - let __v_27: G = __loaded[10]; - match __v_17.as_canonical_u64() { + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_11, __v_15]; 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_17: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + match __v_18.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_1, __v_14, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __v_9, __v_10, __v_11]; 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_28: G = __r_arr[0]; - let __v_29: G = G::from_u64(1); - let __v_30: G = (__v_12 + __v_29); - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__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_30]; 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_31: G = __r_arr[0]; - let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 3] = [__v_32, __v_28, __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_542] = [__v_33]; - record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_1, __v_15, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13, __v_10, __v_11, __v_12]; 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_29: G = __r_arr[0]; + let __v_30: G = G::from_u64(1); + let __v_31: G = (__v_13 + __v_30); + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_31]; 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 = __r_arr[0]; + let __v_33: G = G::from_u64(0); + let __v_34: G = { let __values: [G; 3] = [__v_33, __v_29, __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 __ret: [G; OUT_544] = [__v_34]; + record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); }, } }) } -const INPUT_SIZE_543: usize = 7; -const IN_543: usize = 7; -const OUT_543: usize = 1; -fn aiur_fn_543( - inp: [G; IN_543], +const INPUT_SIZE_545: usize = 7; +const IN_545: usize = 7; +const OUT_545: usize = 1; +fn aiur_fn_545( + inp: [G; IN_545], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_543], 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]; @@ -47578,23 +47719,23 @@ fn aiur_fn_543( 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_544] = { let __args: [G; IN_544] = [__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[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_546] = { let __args: [G; IN_546] = [__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[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_8: G = __r_arr[0]; - let __ret: [G; OUT_543] = [__v_8]; - record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_545] = [__v_8]; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_544: usize = 8; -const IN_544: usize = 8; -const OUT_544: usize = 1; -fn aiur_fn_544( - inp: [G; IN_544], +const INPUT_SIZE_546: usize = 8; +const IN_546: usize = 8; +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_544], 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]; @@ -47616,12 +47757,12 @@ fn aiur_fn_544( 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_544] = [__v_16]; - record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_546] = [__v_16]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_9]; 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_726] = { let __args: [G; IN_726] = [__v_6, __v_9]; 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_14: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -47645,18 +47786,18 @@ fn aiur_fn_544( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(1); let __v_31: G = (__v_7 + __v_30); - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_31]; 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_546] = { let __args: [G; IN_546] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_31]; 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_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 3] = [__v_29, __v_28, __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 __ret: [G; OUT_544] = [__v_33]; - record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_546] = [__v_33]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_546] = { let __args: [G; IN_546] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_26: G = __r_arr[0]; - let __ret: [G; OUT_544] = [__v_26]; - record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_546] = [__v_26]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47668,15 +47809,44 @@ fn aiur_fn_544( }) } -const INPUT_SIZE_545: usize = 11; -const IN_545: usize = 11; -const OUT_545: usize = 1; -fn aiur_fn_545( - inp: [G; IN_545], +const INPUT_SIZE_547: usize = 11; +const IN_547: usize = 11; +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_545], 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 __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_0, __v_1, __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[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 __v_11: G = __r_arr[0]; + let __ret: [G; OUT_547] = [__v_11]; + record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_548: usize = 12; +const IN_548: usize = 12; +const OUT_548: usize = 1; +fn aiur_fn_548( + inp: [G; IN_548], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; @@ -47689,77 +47859,78 @@ fn aiur_fn_545( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; + let __v_11: G = inp[11]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; - let __v_11: G = __loaded[0]; - let __v_12: G = __loaded[1]; - let __v_13: G = __loaded[2]; - let __v_14: G = __loaded[3]; - let __v_15: G = __loaded[4]; - let __v_16: G = __loaded[5]; - match __v_11.as_canonical_u64() { + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + match __v_12.as_canonical_u64() { 1u64 => { - let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); - let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_545] = [__v_19]; - record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_548] = [__v_20]; + record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_12]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; - let __v_18: G = __loaded[0]; - let __v_19: G = __loaded[1]; - let __v_20: G = __loaded[2]; - let __v_21: G = __loaded[3]; - let __v_22: G = __loaded[4]; - let __v_23: G = __loaded[5]; - let __v_24: G = __loaded[6]; - let __v_25: G = __loaded[7]; - let __v_26: G = __loaded[8]; - let __v_27: G = __loaded[9]; - let __v_28: G = __loaded[10]; - match __v_18.as_canonical_u64() { + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_9, __v_13]; 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_18: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + let __v_29: G = __loaded[10]; + match __v_19.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_23, __v_12, __v_13, __v_14, __v_15, __v_1, __v_2, __v_3, __v_4, __v_7, __v_8, __v_9, __v_10]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_24, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11]; 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_30: G = __r_arr[0]; - let __v_31: G = (__v_10 + __v_30); - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_31]; 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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_29, __v_32]; 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_197] = { let __args: [G; IN_197] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = (__v_11 + __v_31); + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_32]; 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 __v_33: G = __r_arr[0]; - let __ret: [G; OUT_545] = [__v_33]; - record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_30, __v_33]; 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_34: G = __r_arr[0]; + let __ret: [G; OUT_548] = [__v_34]; + record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_16, __v_1, __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[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_29: G = __r_arr[0]; - let __ret: [G; OUT_545] = [__v_29]; - record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_17, __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[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 __v_30: G = __r_arr[0]; + let __ret: [G; OUT_548] = [__v_30]; + record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); }, } }) } -const INPUT_SIZE_546: usize = 10; -const IN_546: usize = 10; -const OUT_546: usize = 1; -fn aiur_fn_546( - inp: [G; IN_546], +const INPUT_SIZE_549: usize = 10; +const IN_549: usize = 10; +const OUT_549: usize = 1; +fn aiur_fn_549( + inp: [G; IN_549], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_546], 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]; @@ -47798,47 +47969,47 @@ fn aiur_fn_546( let __v_13: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_7, __v_8]; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_14, __v_12, __v_8]; 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_565] = { let __args: [G; IN_565] = [__v_14, __v_12, __v_8]; 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 __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_15]; 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_572] = { let __args: [G; IN_572] = [__v_15]; 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_16: G = __r_arr[0]; - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_15]; 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_740] = { let __args: [G; IN_740] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_16, __v_0, __v_18]; 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_535] = { let __args: [G; IN_535] = [__v_16, __v_0, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_15, __v_20]; 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_573] = { let __args: [G; IN_573] = [__v_15, __v_20]; 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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_25, __v_3]; 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_541] = { let __args: [G; IN_541] = [__v_25, __v_3]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_15, __v_8]; 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_575] = { let __args: [G; IN_575] = [__v_15, __v_8]; 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 __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_15, __v_3, __v_5, __v_13, __v_12, __v_3, __v_8]; 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_545] = { let __args: [G; IN_545] = [__v_15, __v_3, __v_5, __v_13, __v_12, __v_3, __v_8]; 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_29: G = __r_arr[0]; let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __v_16, __v_28, __v_3, __v_17, __v_5, __v_12, __v_3, __v_8, __v_9, __v_30]; 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_547] = { let __args: [G; IN_547] = [__v_15, __v_16, __v_28, __v_3, __v_17, __v_5, __v_12, __v_3, __v_8, __v_9, __v_30]; 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_31: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_27, __v_4]; 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_541] = { let __args: [G; IN_541] = [__v_27, __v_4]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = (__v_17 + __v_32); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_33, __v_35, __v_36]; 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_559] = { let __args: [G; IN_559] = [__v_33, __v_35, __v_36]; 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_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_16, __v_0, __v_38]; 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_535] = { let __args: [G; IN_535] = [__v_16, __v_0, __v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_15, __v_40]; 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_573] = { let __args: [G; IN_573] = [__v_15, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -47851,7 +48022,7 @@ fn aiur_fn_546( let __v_50: G = (__v_3 + __v_49); let __v_51: G = G::from_u64(1); let __v_52: G = (__v_50 - __v_51); - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_47, __v_3, __v_52, __v_4, __v_42, __v_43]; 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 __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_47, __v_3, __v_52, __v_4, __v_42, __v_43]; 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_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_53, __v_4, __v_54]; 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)? } }; @@ -47866,7 +48037,7 @@ fn aiur_fn_546( let __v_63: G = G::from_u64(0); let __v_64: G = { let __values: [G; 4] = [__v_62, __v_61, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0); - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_64, __v_4, __v_65]; 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_543] = { let __args: [G; IN_543] = [__v_64, __v_4, __v_65]; 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_66: G = __r_arr[0]; let __v_67: G = G::from_u64(3); let __v_68: G = G::from_u64(0); @@ -47886,21 +48057,21 @@ fn aiur_fn_546( let __v_79: G = __r_arr[0]; let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_79, __v_26]; 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_80: G = __r_arr[0]; - let __ret: [G; OUT_546] = [__v_80]; - record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_549] = [__v_80]; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_547: usize = 21; -const IN_547: usize = 21; -const OUT_547: usize = 1; -fn aiur_fn_547( - inp: [G; IN_547], +const INPUT_SIZE_550: usize = 22; +const IN_550: usize = 22; +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_547], 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]; @@ -47923,85 +48094,86 @@ fn aiur_fn_547( let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; - let __v_21: G = (__v_8 + __v_9); - let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_21, __v_22]; 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 __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __v_21: G = inp[21]; + let __v_22: G = (__v_8 + __v_9); + let __v_23: G = G::from_u64(0); + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_22, __v_23]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_19]; 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_232] = { let __args: [G; IN_232] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_24, __v_25, __v_16, __v_17]; 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_2, __v_20]; 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_26: G = __r_arr[0]; - let __v_27: G = G::from_u64(1); + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_25, __v_26, __v_17, __v_18]; 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_27: G = __r_arr[0]; 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_30: 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(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_33: G = G::from_u64(1); + let __v_32: G = G::from_u64(1); + let __v_33: G = { let __values: [G; 3] = [__v_31, __v_32, __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 = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_36: G = G::from_u64(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 __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 = G::from_u64(0); - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_26, __v_14, __v_29, __v_32, __v_35, __v_38, __v_19, __v_20, __v_39]; 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_40: G = __r_arr[0]; - let __v_41: G = __r_arr[1]; - let __v_42: G = __r_arr[2]; - let __v_43: G = __r_arr[3]; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; - let __v_44: G = __r_arr[0]; + let __v_38: G = G::from_u64(1); + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = G::from_u64(0); + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_27, __v_14, __v_30, __v_33, __v_36, __v_39, __v_20, __v_21, __v_40]; 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_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __v_43: G = __r_arr[2]; + let __v_44: G = __r_arr[3]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __v_46: G = (__v_7 + __v_44); - let __v_47: G = (__v_6 + __v_46); - let __v_48: G = (__v_5 + __v_47); - let __v_49: G = G::from_u64(1); - let __v_50: G = (__v_48 - __v_49); - let __v_51: G = (__v_6 + __v_4); - let __v_52: G = (__v_5 + __v_51); - let __v_53: G = (__v_50 - __v_52); - let __v_54: G = G::from_u64(0); + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __v_47: G = (__v_7 + __v_45); + let __v_48: G = (__v_6 + __v_47); + let __v_49: G = (__v_5 + __v_48); + let __v_50: G = G::from_u64(1); + let __v_51: G = (__v_49 - __v_50); + let __v_52: G = (__v_6 + __v_4); + let __v_53: G = (__v_5 + __v_52); + let __v_54: G = (__v_51 - __v_53); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __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 __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_56, __v_44, __v_44, __v_57]; 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 __v_58: G = __r_arr[0]; - let __v_59: G = G::from_u64(1); + let __v_56: G = G::from_u64(0); + let __v_57: G = { let __values: [G; 4] = [__v_55, __v_54, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_57, __v_45, __v_45, __v_58]; 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_59: G = __r_arr[0]; let __v_60: G = G::from_u64(1); - let __v_61: G = { let __values: [G; 3] = [__v_59, __v_60, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_58, __v_41, __v_42, __v_40, __v_13, __v_15, __v_5, __v_6, __v_7, __v_44, __v_23, __v_61, __v_19, __v_20, __v_62]; 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_63: G = __r_arr[0]; - let __v_64: G = (__v_6 + __v_7); - let __v_65: G = G::from_u64(0); - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_40, __v_64, __v_65]; 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_66: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_63, __v_66]; 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_61: G = G::from_u64(1); + let __v_62: G = { let __values: [G; 3] = [__v_60, __v_61, __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 = G::from_u64(0); + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_59, __v_42, __v_43, __v_41, __v_13, __v_16, __v_5, __v_6, __v_7, __v_45, __v_24, __v_62, __v_20, __v_21, __v_63]; 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_64: G = __r_arr[0]; + let __v_65: G = (__v_6 + __v_7); + let __v_66: G = G::from_u64(0); + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_41, __v_65, __v_66]; 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_67: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_67, __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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_64, __v_67]; 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_68: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_68, __v_10]; 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_552] = { let __args: [G; IN_552] = [__v_68, __v_11]; 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_69: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_69, __v_12]; 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_552] = { let __args: [G; IN_552] = [__v_69, __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_70: G = __r_arr[0]; - let __ret: [G; OUT_547] = [__v_70]; - record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_70, __v_12]; 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_71: G = __r_arr[0]; + let __ret: [G; OUT_550] = [__v_71]; + record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_548: usize = 2; -const IN_548: usize = 2; -const OUT_548: usize = 1; -fn aiur_fn_548( - inp: [G; IN_548], +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_548], 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]; @@ -48011,8 +48183,8 @@ fn aiur_fn_548( 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_548] = [__v_5]; - record.function_queries[548].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)); return Ok(__ret); }, _ => { @@ -48022,26 +48194,26 @@ fn aiur_fn_548( 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_548] = { let __args: [G; IN_548] = [__v_0, __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 __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_8]; 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_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_548] = [__v_10]; - record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_551] = [__v_10]; + record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_549: usize = 2; -const IN_549: usize = 2; -const OUT_549: usize = 1; -fn aiur_fn_549( - inp: [G; IN_549], +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_549], 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]; @@ -48051,18 +48223,18 @@ fn aiur_fn_549( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_549] = [__v_0]; - record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_552] = [__v_0]; + record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_4]; 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_552] = { let __args: [G; IN_552] = [__v_0, __v_4]; 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 __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_549] = [__v_8]; - record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_552] = [__v_8]; + record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48072,15 +48244,15 @@ fn aiur_fn_549( }) } -const INPUT_SIZE_550: usize = 15; -const IN_550: usize = 15; -const OUT_550: usize = 1; -fn aiur_fn_550( - inp: [G; IN_550], +const INPUT_SIZE_553: usize = 15; +const IN_553: usize = 15; +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_550], 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]; @@ -48103,21 +48275,21 @@ fn aiur_fn_550( let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_550] = [__v_0]; - record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_0]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __v_14]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __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_726] = { let __args: [G; IN_726] = [__v_4, __v_18]; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __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_726] = { let __args: [G; IN_726] = [__v_5, __v_18]; 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_20: G = __r_arr[0]; let __v_21: G = (__v_8 + __v_9); let __v_22: G = (__v_7 + __v_21); let __v_23: G = (__v_6 + __v_22); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_16]; 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_24: G = __r_arr[0]; let __v_25: G = (__v_9 - __v_16); let __v_26: G = G::from_u64(0); @@ -48128,12 +48300,12 @@ fn aiur_fn_550( let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_11, __v_12, __v_13]; 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_30: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_30]; 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_536] = { let __args: [G; IN_536] = [__v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_31]; 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_724] = { let __args: [G; IN_724] = [__v_31]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_33, __v_11]; 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_721] = { let __args: [G; IN_721] = [__v_33, __v_11]; 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_34: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_32, __v_34, __v_12, __v_13]; 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_35: G = __r_arr[0]; @@ -48146,25 +48318,25 @@ fn aiur_fn_550( let __v_41: G = G::from_u64(1); let __v_42: G = (__v_37 - __v_41); let __v_43: G = G::from_u64(0); - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_40, __v_6, __v_42, __v_43]; 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_539] = { let __args: [G; IN_539] = [__v_40, __v_6, __v_42, __v_43]; 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_44: G = __r_arr[0]; let __v_45: G = G::from_u64(1); let __v_46: G = (__v_37 - __v_45); let __v_47: G = (__v_46 - __v_6); let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_44, __v_7, __v_47, __v_48]; 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_539] = { let __args: [G; IN_539] = [__v_44, __v_7, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_37 - __v_50); let __v_52: G = (__v_51 - __v_6); let __v_53: G = (__v_52 - __v_7); let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_49, __v_8, __v_53, __v_54]; 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_539] = { let __args: [G; IN_539] = [__v_49, __v_8, __v_53, __v_54]; 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_55: G = __r_arr[0]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_57, __v_20]; 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_741] = { let __args: [G; IN_741] = [__v_57, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_55, __v_58]; 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_59: G = __r_arr[0]; @@ -48181,17 +48353,17 @@ fn aiur_fn_550( 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_59, __v_68, __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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_71, __v_31]; 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_552] = { let __args: [G; IN_552] = [__v_71, __v_31]; 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_72: G = __r_arr[0]; let __v_73: G = G::from_u64(3); let __v_74: G = G::from_u64(0); let __v_75: G = { let __values: [G; 4] = [__v_73, __v_0, __v_72, __v_74]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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(1); let __v_77: G = (__v_14 + __v_76); - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_75, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_77]; 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_553] = { let __args: [G; IN_553] = [__v_75, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_77]; 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_78: G = __r_arr[0]; - let __ret: [G; OUT_550] = [__v_78]; - record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_78]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48201,15 +48373,15 @@ fn aiur_fn_550( }) } -const INPUT_SIZE_551: usize = 7; -const IN_551: usize = 7; -const OUT_551: usize = 1; -fn aiur_fn_551( - inp: [G; IN_551], +const INPUT_SIZE_554: usize = 7; +const IN_554: usize = 7; +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_551], 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]; @@ -48240,8 +48412,8 @@ fn aiur_fn_551( let __v_20: G = __loaded[3]; match __v_17.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_551] = [__v_18]; - record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_18]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48256,51 +48428,51 @@ fn aiur_fn_551( }) } -const INPUT_SIZE_552: usize = 3; -const IN_552: usize = 3; -const OUT_552: usize = 1; -fn aiur_fn_552( - inp: [G; IN_552], +const INPUT_SIZE_555: usize = 3; +const IN_555: usize = 3; +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_552], ExecError> { +) -> Result<[G; OUT_555], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1, __v_3, __v_2, __v_2, __v_4]; 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_556] = { let __args: [G; IN_556] = [__v_0, __v_1, __v_3, __v_2, __v_2, __v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1, __v_6, __v_2, __v_2, __v_7]; 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_556] = { let __args: [G; IN_556] = [__v_0, __v_1, __v_6, __v_2, __v_2, __v_7]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_552] = [__v_8]; - record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_555] = [__v_8]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_552] = [__v_5]; - record.function_queries[552].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); }, } }) } -const INPUT_SIZE_553: usize = 6; -const IN_553: usize = 6; -const OUT_553: usize = 1; -fn aiur_fn_553( - inp: [G; IN_553], +const INPUT_SIZE_556: usize = 6; +const IN_556: usize = 6; +const OUT_556: usize = 1; +fn aiur_fn_556( + inp: [G; IN_556], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_553], 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]; @@ -48315,8 +48487,8 @@ fn aiur_fn_553( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_553] = [__v_9]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_556] = [__v_9]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -48334,7 +48506,7 @@ fn aiur_fn_553( let __v_19: G = __loaded[10]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_16, __v_11, __v_12, __v_14, __v_15, __v_13, __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_554] = { let __args: [G; IN_554] = [__v_16, __v_11, __v_12, __v_14, __v_15, __v_13, __v_4]; 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_20: G = __r_arr[0]; let __v_21: G = (__v_20 - __v_0); let __v_22: G = G::from_bool((__v_21 == G::ZERO)); @@ -48354,17 +48526,17 @@ fn aiur_fn_553( let __v_24: G = (__v_22 * __v_23); match __v_24.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_553] = [__v_5]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_556] = [__v_5]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_25: G = G::from_u64(1); let __v_26: G = (__v_5 + __v_25); - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_26]; 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_556] = { let __args: [G; IN_556] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_26]; 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_27: G = __r_arr[0]; - let __ret: [G; OUT_553] = [__v_27]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_556] = [__v_27]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48375,10 +48547,10 @@ fn aiur_fn_553( _ => { let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_21]; 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_556] = { let __args: [G; IN_556] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_21]; 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_22: G = __r_arr[0]; - let __ret: [G; OUT_553] = [__v_22]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_556] = [__v_22]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48390,15 +48562,15 @@ fn aiur_fn_553( }) } -const INPUT_SIZE_554: usize = 3; -const IN_554: usize = 3; -const OUT_554: usize = 1; -fn aiur_fn_554( - inp: [G; IN_554], +const INPUT_SIZE_557: usize = 3; +const IN_557: usize = 3; +const OUT_557: usize = 1; +fn aiur_fn_557( + inp: [G; IN_557], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_554], 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]; @@ -48412,19 +48584,19 @@ fn aiur_fn_554( 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_554] = [__v_8]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_557] = [__v_8]; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_4, __v_1, __v_2]; 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_555] = { let __args: [G; IN_555] = [__v_4, __v_1, __v_2]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_5, __v_1, __v_2]; 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_557] = { let __args: [G; IN_557] = [__v_5, __v_1, __v_2]; 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 __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_554] = [__v_9]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_557] = [__v_9]; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48434,15 +48606,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_558: usize = 2; +const IN_558: usize = 2; +const OUT_558: usize = 1; +fn aiur_fn_558( + inp: [G; IN_558], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_555], 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]; @@ -48456,7 +48628,7 @@ fn aiur_fn_555( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -48472,8 +48644,8 @@ fn aiur_fn_555( let __v_18: G = __loaded[10]; match __v_8.as_canonical_u64() { 6u64 => { - let __ret: [G; OUT_555] = [__v_11]; - record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_558] = [__v_11]; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48490,15 +48662,15 @@ fn aiur_fn_555( }) } -const INPUT_SIZE_556: usize = 3; -const IN_556: usize = 3; -const OUT_556: usize = 1; -fn aiur_fn_556( - inp: [G; IN_556], +const INPUT_SIZE_559: usize = 3; +const IN_559: usize = 3; +const OUT_559: usize = 1; +fn aiur_fn_559( + inp: [G; IN_559], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_556], 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]; @@ -48512,8 +48684,8 @@ fn aiur_fn_556( 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_556] = [__v_8]; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_559] = [__v_8]; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -48522,11 +48694,11 @@ fn aiur_fn_556( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_5, __v_1, __v_9]; 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_559] = { let __args: [G; IN_559] = [__v_5, __v_1, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_6, __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_556] = [__v_11]; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_559] = [__v_11]; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48536,15 +48708,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_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_557], 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]; @@ -48566,8 +48738,8 @@ fn aiur_fn_557( let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_557] = []; - record.function_queries[557].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); }, _ => { @@ -48603,9 +48775,9 @@ fn aiur_fn_557( if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); } - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_8, __v_13, __v_2, __v_3]; 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_560] = { let __args: [G; IN_560] = [__v_8, __v_13, __v_2, __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)); return Ok(__ret); }, } @@ -48624,15 +48796,15 @@ fn aiur_fn_557( }) } -const INPUT_SIZE_558: usize = 13; -const IN_558: usize = 13; -const OUT_558: usize = 0; -fn aiur_fn_558( - inp: [G; IN_558], +const INPUT_SIZE_561: usize = 13; +const IN_561: usize = 13; +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_558], 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]; @@ -48649,7 +48821,7 @@ fn aiur_fn_558( let __v_12: G = inp[12]; match __v_1.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __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_726] = { let __args: [G; IN_726] = [__v_12, __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_13: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -48665,13 +48837,13 @@ fn aiur_fn_558( let __v_24: G = __loaded[10]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __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_726] = { let __args: [G; IN_726] = [__v_19, __v_5]; 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_25: G = __r_arr[0]; if (__v_25 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_0.as_canonical_u64() }); } - let __ret: [G; OUT_558] = []; - record.function_queries[558].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); }, _ => { @@ -48686,19 +48858,19 @@ fn aiur_fn_558( }) } -const INPUT_SIZE_559: usize = 2; -const IN_559: usize = 2; -const OUT_559: usize = 1; -fn aiur_fn_559( - inp: [G; IN_559], +const INPUT_SIZE_562: usize = 2; +const IN_562: usize = 2; +const OUT_562: usize = 1; +fn aiur_fn_562( + inp: [G; IN_562], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_559], ExecError> { +) -> Result<[G; OUT_562], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __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_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -48733,8 +48905,8 @@ fn aiur_fn_559( match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_559] = [__v_24]; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_562] = [__v_24]; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -48745,9 +48917,9 @@ fn aiur_fn_559( match __v_26.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_27]; 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_726] = { let __args: [G; IN_726] = [__v_8, __v_27]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_28]; 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_29: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_29.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_30: G = __loaded[0]; @@ -48764,22 +48936,22 @@ fn aiur_fn_559( match __v_30.as_canonical_u64() { 6u64 => { let __v_41: G = G::from_bool((__v_36 == G::ZERO)); - let __ret: [G; OUT_559] = [__v_41]; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_562] = [__v_41]; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_41: G = G::from_u64(0); - let __ret: [G; OUT_559] = [__v_41]; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_562] = [__v_41]; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_559] = [__v_27]; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_562] = [__v_27]; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48791,31 +48963,250 @@ fn aiur_fn_559( }, _ => { let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_559] = [__v_18]; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_562] = [__v_18]; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_559] = [__v_14]; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_562] = [__v_14]; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_560: usize = 14; -const IN_560: usize = 14; -const OUT_560: usize = 0; -fn aiur_fn_560( - inp: [G; IN_560], +const INPUT_SIZE_563: usize = 2; +const IN_563: usize = 2; +const OUT_563: usize = 1; +fn aiur_fn_563( + inp: [G; IN_563], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_560], ExecError> { +) -> Result<[G; OUT_563], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(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() { + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_10: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_11: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_12: G = (__v_10 + __v_11); + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(1); + let __ret: [G; OUT_563] = [__v_13]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_13]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_10]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_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]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_563] = [__v_10]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_10]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_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]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 2u64 => { + let __v_10: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_11: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_12: G = (__v_10 + __v_11); + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(1); + let __ret: [G; OUT_563] = [__v_13]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_13]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_10]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_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]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_3, __v_7]; 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 __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __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 __v_11: G = __r_arr[0]; + let __ret: [G; OUT_563] = [__v_11]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_11]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_10]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_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]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_3, __v_7]; 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 __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __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 __v_11: G = __r_arr[0]; + let __ret: [G; OUT_563] = [__v_11]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_11]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_10]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_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]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_3, __v_7]; 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 __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __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 __v_11: G = __r_arr[0]; + let __ret: [G; OUT_563] = [__v_11]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_11]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_10]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_563] = [__v_6]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_564: usize = 14; +const IN_564: usize = 14; +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_564], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48833,16 +49224,16 @@ fn aiur_fn_560( let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; 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_554] = { let __args: [G; IN_554] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_14, __v_11, __v_12]; 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_576] = { let __args: [G; IN_576] = [__v_14, __v_11, __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_15: G = __r_arr[0]; - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_14, __v_12]; 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_562] = { let __args: [G; IN_562] = [__v_14, __v_12]; 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_16: G = __r_arr[0]; if (__v_9 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); } - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __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_726] = { let __args: [G; IN_726] = [__v_12, __v_15]; 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_17: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; @@ -48856,7 +49247,7 @@ fn aiur_fn_560( let __v_26: G = __loaded[8]; let __v_27: G = __loaded[9]; let __v_28: G = __loaded[10]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __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_726] = { let __args: [G; IN_726] = [__v_12, __v_14]; 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_29: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_29.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_30: G = __loaded[0]; @@ -48874,7 +49265,7 @@ fn aiur_fn_560( 5u64 => { match __v_30.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_12, __v_13]; 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_549] = { let __args: [G; IN_549] = [__v_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_12, __v_13]; 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_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); @@ -48912,48 +49303,48 @@ fn aiur_fn_560( let __v_50: G = __mc_out___mc_0[0]; let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_15, __v_12]; 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_51: G = __r_arr[0]; - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_51, __v_49, __v_12]; 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_565] = { let __args: [G; IN_565] = [__v_51, __v_49, __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 __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_52]; 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_572] = { let __args: [G; IN_572] = [__v_52]; 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_53: G = __r_arr[0]; - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_52]; 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_740] = { let __args: [G; IN_740] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_52, __v_12]; 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_575] = { let __args: [G; IN_575] = [__v_52, __v_12]; 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_55: G = __r_arr[0]; - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_52, __v_21, __v_19, __v_50, __v_49, __v_21, __v_12]; 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_545] = { let __args: [G; IN_545] = [__v_52, __v_21, __v_19, __v_50, __v_49, __v_21, __v_12]; 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_56: G = __r_arr[0]; let __v_57: G = G::from_u64(0); - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_52, __v_53, __v_55, __v_21, __v_54, __v_19, __v_49, __v_21, __v_12, __v_13, __v_57]; 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_547] = { let __args: [G; IN_547] = [__v_52, __v_53, __v_55, __v_21, __v_54, __v_19, __v_49, __v_21, __v_12, __v_13, __v_57]; 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_58: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_53, __v_14, __v_12, __v_60]; 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_578] = { let __args: [G; IN_578] = [__v_53, __v_14, __v_12, __v_60]; 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_61: G = __r_arr[0]; let __v_62: G = G::from_u64(0); let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_49, __v_19, __v_62]; 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_63: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_20, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_64, __v_21]; 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_541] = { let __args: [G; IN_541] = [__v_64, __v_21]; 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_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_53, __v_11, __v_12]; 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_557] = { let __args: [G; IN_557] = [__v_53, __v_11, __v_12]; 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 __v_67: G = __r_arr[0]; let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_53, __v_14, __v_68]; 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_535] = { let __args: [G; IN_535] = [__v_53, __v_14, __v_68]; 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_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_52, __v_70]; 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_573] = { let __args: [G; IN_573] = [__v_52, __v_70]; 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_71: G = __r_arr[0]; let __v_72: G = __r_arr[1]; let __v_73: G = __r_arr[2]; let __v_74: G = __r_arr[3]; - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_0, __v_14, __v_35, __v_21, __v_54, __v_59, __v_19, __v_49, __v_56, __v_58, __v_65, __v_67, __v_53, __v_55, __v_72, __v_73, __v_74, __v_12, __v_13, __v_61]; 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_593] = { let __args: [G; IN_593] = [__v_0, __v_14, __v_35, __v_21, __v_54, __v_59, __v_19, __v_49, __v_56, __v_58, __v_65, __v_67, __v_52, __v_53, __v_55, __v_72, __v_73, __v_74, __v_12, __v_13, __v_61]; 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 __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_8, __v_75, __v_12, __v_13]; 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_560] = []; - record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_8, __v_75, __v_12, __v_13]; 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_564] = []; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48973,42 +49364,335 @@ fn aiur_fn_560( }) } -const INPUT_SIZE_561: usize = 3; -const IN_561: usize = 3; -const OUT_561: usize = 1; -fn aiur_fn_561( - inp: [G; IN_561], +const INPUT_SIZE_565: usize = 3; +const IN_565: usize = 3; +const OUT_565: usize = 1; +fn aiur_fn_565( + inp: [G; IN_565], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_561], ExecError> { +) -> Result<[G; OUT_565], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !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_571] = { let __args: [G; IN_571] = [__v_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_0, __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_563] = { let __args: [G; IN_563] = [__v_4]; 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 __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_3, __v_4, __v_0, __v_2]; 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 __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_561] = [__v_6]; - record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_565] = [__v_5]; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_562: usize = 3; -const IN_562: usize = 3; -const OUT_562: usize = 1; -fn aiur_fn_562( - inp: [G; IN_562], +const INPUT_SIZE_566: usize = 4; +const IN_566: usize = 4; +const OUT_566: usize = 1; +fn aiur_fn_566( + inp: [G; IN_566], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_562], ExecError> { +) -> Result<[G; OUT_566], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = { let __a_val = __v_1.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() { + 0u64 => { + let __ret: [G; OUT_566] = [__v_0]; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_1]; 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_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_6, __v_7, __v_8, __v_9, __v_2, __v_3]; 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_10: G = __r_arr[0]; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_10]; 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_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_1 + __v_12); + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_11, __v_13, __v_2, __v_3]; 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 __v_14: G = __r_arr[0]; + let __ret: [G; OUT_566] = [__v_14]; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_567: usize = 6; +const IN_567: usize = 6; +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_567], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __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_6: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_12, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_18: G = __r_arr[0]; + let __ret: [G; OUT_567] = [__v_18]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 5] = [__v_18, __v_19, __v_19, __v_19, __v_19]; 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_567] = [__v_20]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_568: usize = 7; +const IN_568: usize = 7; +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_568], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 5] = [__v_10, __v_11, __v_11, __v_11, __v_11]; 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_568] = [__v_12]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_6, __v_8]; 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_10: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + let __v_17: G = __loaded[6]; + let __v_18: G = __loaded[7]; + let __v_19: G = __loaded[8]; + let __v_20: G = __loaded[9]; + let __v_21: G = __loaded[10]; + match __v_11.as_canonical_u64() { + 6u64 => { + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_13, __v_1]; 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_22: G = __r_arr[0]; + break '__mc_0 [__v_22]; + }, + _ => { + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_22, __v_1, __v_3]; 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_23: G = __r_arr[0]; + break '__mc_0 [__v_23]; + }, +} + }; + let __v_22: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_22, __v_5, __v_6]; 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_23: G = __r_arr[0]; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_24: G = __r_arr[0]; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_23, __v_24]; 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_25: G = __r_arr[0]; + let __ret: [G; OUT_568] = [__v_25]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_22: G = __r_arr[0]; + let __ret: [G; OUT_568] = [__v_22]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_569: usize = 2; +const IN_569: usize = 2; +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_569], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_569] = [__v_0]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_3]; 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 = __r_arr[0]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_6]; 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)); + return Ok(__ret); + }, + _ => { + 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 = 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_13: G = { let __values: [G; 6] = [__v_8, __v_3, __v_9, __v_4, __v_5, __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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_13]; 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_14: G = __r_arr[0]; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_14, __v_6]; 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_15: G = __r_arr[0]; + let __ret: [G; OUT_569] = [__v_15]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_570], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_570] = [__v_8]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_10: G = (__v_8 + __v_9); + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_570] = [__v_11]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_7, __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_11: G = __r_arr[0]; + let __ret: [G; OUT_570] = [__v_11]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_571: usize = 3; +const IN_571: usize = 3; +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_571], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49022,12 +49706,12 @@ fn aiur_fn_562( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 6] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_562] = [__v_8]; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_8]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __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_6: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -49051,11 +49735,11 @@ fn aiur_fn_562( 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 __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !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_571] = { let __args: [G; IN_571] = [__v_5, __v_1, __v_2]; 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_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 6] = [__v_20, __v_4, __v_21, __v_24, __v_19, __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_562] = [__v_26]; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_26]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49067,11 +49751,11 @@ fn aiur_fn_562( 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_5, __v_1, __v_2]; 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_571] = { let __args: [G; IN_571] = [__v_5, __v_1, __v_2]; 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_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 6] = [__v_18, __v_4, __v_19, __v_22, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_562] = [__v_27]; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_27]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49083,58 +49767,15 @@ fn aiur_fn_562( }) } -const INPUT_SIZE_563: usize = 1; -const IN_563: usize = 1; -const OUT_563: usize = 1; -fn aiur_fn_563( - inp: [G; IN_563], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_563], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; - let __v_1: G = __loaded[0]; - let __v_2: G = __loaded[1]; - let __v_3: G = __loaded[2]; - let __v_4: G = __loaded[3]; - let __v_5: G = __loaded[4]; - match __v_1.as_canonical_u64() { - 1u64 => { - let __v_6: G = G::from_u64(1); - let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 6] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_563] = [__v_8]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 0u64 => { - let __v_6: G = G::from_u64(0); - let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5]; 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 __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 6] = [__v_6, __v_2, __v_7, __v_3, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_563] = [__v_9]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_564: usize = 1; -const IN_564: usize = 1; -const OUT_564: usize = 1; -fn aiur_fn_564( - inp: [G; IN_564], +const INPUT_SIZE_572: usize = 1; +const IN_572: usize = 1; +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_564], ExecError> { +) -> Result<[G; OUT_572], 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 }; @@ -49149,17 +49790,17 @@ fn aiur_fn_564( 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_564] = [__v_9]; - record.function_queries[564].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); }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_6]; 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_572] = { let __args: [G; IN_572] = [__v_6]; 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_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_7, __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 __ret: [G; OUT_564] = [__v_9]; - record.function_queries[564].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); }, _ => { @@ -49169,15 +49810,15 @@ fn aiur_fn_564( }) } -const INPUT_SIZE_565: usize = 2; -const IN_565: usize = 2; -const OUT_565: usize = 4; -fn aiur_fn_565( - inp: [G; IN_565], +const INPUT_SIZE_573: usize = 2; +const IN_573: usize = 2; +const OUT_573: usize = 4; +fn aiur_fn_573( + inp: [G; IN_573], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_565], 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]; @@ -49198,27 +49839,27 @@ fn aiur_fn_565( 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_565] = [__v_8, __v_9, __v_12, __v_15]; - record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_8, __v_9, __v_12, __v_15]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_565] = [__v_3, __v_4, __v_5, __v_6]; - record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_3, __v_4, __v_5, __v_6]; + record.function_queries[573].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_565] = { let __args: [G; IN_565] = [__v_7, __v_9]; 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_573] = { let __args: [G; IN_573] = [__v_7, __v_9]; 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_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_565] = [__v_10, __v_11, __v_12, __v_13]; - record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_10, __v_11, __v_12, __v_13]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49230,15 +49871,15 @@ fn aiur_fn_565( }) } -const INPUT_SIZE_566: usize = 6; -const IN_566: usize = 6; -const OUT_566: usize = 1; -fn aiur_fn_566( - inp: [G; IN_566], +const INPUT_SIZE_574: usize = 6; +const IN_574: usize = 6; +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_566], 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]; @@ -49249,32 +49890,32 @@ fn aiur_fn_566( match __v_4.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_0, __v_1, __v_2, __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_539] = { let __args: [G; IN_539] = [__v_0, __v_1, __v_2, __v_6]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_566] = [__v_7]; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_574] = [__v_7]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __v_5, __v_3]; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_566] = [__v_6]; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_574] = [__v_6]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_567: usize = 2; -const IN_567: usize = 2; -const OUT_567: usize = 1; -fn aiur_fn_567( - inp: [G; IN_567], +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_567], 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]; @@ -49290,12 +49931,12 @@ fn aiur_fn_567( 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 __ret: [G; OUT_567] = [__v_10]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_10]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -49312,21 +49953,21 @@ fn aiur_fn_567( match __v_9.as_canonical_u64() { 5u64 => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_7, __v_1]; 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_575] = { let __args: [G; IN_575] = [__v_7, __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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_12, __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_567] = [__v_22]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_22]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_7, __v_1]; 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_575] = { let __args: [G; IN_575] = [__v_7, __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_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_20, __v_21, __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_567] = [__v_23]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_23]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49338,15 +49979,15 @@ fn aiur_fn_567( }) } -const INPUT_SIZE_568: usize = 3; -const IN_568: usize = 3; -const OUT_568: usize = 1; -fn aiur_fn_568( - inp: [G; IN_568], +const INPUT_SIZE_576: usize = 3; +const IN_576: usize = 3; +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_568], 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]; @@ -49388,24 +50029,24 @@ fn aiur_fn_568( let __v_36: G = __r_arr[0]; match __v_36.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_568] = [__v_0]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_0]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_1, __v_2, __v_2, __v_37]; 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_577] = { let __args: [G; IN_577] = [__v_1, __v_2, __v_2, __v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; match __v_38.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_568] = [__v_39]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_39]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_568] = [__v_0]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_0]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49417,15 +50058,15 @@ fn aiur_fn_568( }) } -const INPUT_SIZE_569: usize = 4; -const IN_569: usize = 4; -const OUT_569: usize = 2; -fn aiur_fn_569( - inp: [G; IN_569], +const INPUT_SIZE_577: usize = 4; +const IN_577: usize = 4; +const OUT_577: usize = 2; +fn aiur_fn_577( + inp: [G; IN_577], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_569], 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]; @@ -49439,8 +50080,8 @@ fn aiur_fn_569( 1u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_569] = [__v_7, __v_8]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_7, __v_8]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -49464,17 +50105,17 @@ fn aiur_fn_569( 0u64 => { let __v_19: G = G::from_u64(1); let __v_20: G = (__v_3 + __v_19); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_6, __v_2, __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_577] = { let __args: [G; IN_577] = [__v_0, __v_6, __v_2, __v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_569] = [__v_21, __v_22]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_21, __v_22]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; 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_554] = { let __args: [G; IN_554] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_19]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_19]; 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_20: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -49494,17 +50135,17 @@ fn aiur_fn_569( 0u64 => { let __v_32: G = G::from_u64(1); let __v_33: G = (__v_3 + __v_32); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_6, __v_2, __v_33]; 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_577] = { let __args: [G; IN_577] = [__v_0, __v_6, __v_2, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_569] = [__v_34, __v_35]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_34, __v_35]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_32: G = G::from_u64(1); - let __ret: [G; OUT_569] = [__v_32, __v_19]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_32, __v_19]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49512,11 +50153,11 @@ fn aiur_fn_569( _ => { let __v_32: G = G::from_u64(1); let __v_33: G = (__v_3 + __v_32); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_6, __v_2, __v_33]; 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_577] = { let __args: [G; IN_577] = [__v_0, __v_6, __v_2, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_569] = [__v_34, __v_35]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_34, __v_35]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49529,11 +50170,11 @@ fn aiur_fn_569( _ => { let __v_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_6, __v_2, __v_19]; 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_577] = { let __args: [G; IN_577] = [__v_0, __v_6, __v_2, __v_19]; 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 __v_21: G = __r_arr[1]; - let __ret: [G; OUT_569] = [__v_20, __v_21]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_20, __v_21]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49545,15 +50186,15 @@ fn aiur_fn_569( }) } -const INPUT_SIZE_570: usize = 4; -const IN_570: usize = 4; -const OUT_570: usize = 1; -fn aiur_fn_570( - inp: [G; IN_570], +const INPUT_SIZE_578: usize = 4; +const IN_578: usize = 4; +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_570], 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]; @@ -49565,8 +50206,8 @@ fn aiur_fn_570( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_570] = [__v_3]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_578] = [__v_3]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -49574,12 +50215,12 @@ fn aiur_fn_570( let __v_8: G = G::from_bool((__v_7 == G::ZERO)); match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_570] = [__v_3]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_578] = [__v_3]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __v_5]; 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_9: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -49598,17 +50239,17 @@ fn aiur_fn_570( let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_21); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_6, __v_1, __v_2, __v_22]; 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_578] = { let __args: [G; IN_578] = [__v_6, __v_1, __v_2, __v_22]; 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_23: G = __r_arr[0]; - let __ret: [G; OUT_570] = [__v_23]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_578] = [__v_23]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_6, __v_1, __v_2, __v_3]; 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_578] = { let __args: [G; IN_578] = [__v_6, __v_1, __v_2, __v_3]; 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_21: G = __r_arr[0]; - let __ret: [G; OUT_570] = [__v_21]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_578] = [__v_21]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49625,19 +50266,19 @@ 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_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_571], ExecError> { +) -> Result<[G; OUT_579], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __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_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -49691,24 +50332,24 @@ fn aiur_fn_571( match __v_47.as_canonical_u64() { 1u64 => { let __v_48: G = G::from_u64(0); - let __ret: [G; OUT_571] = [__v_48]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_579] = [__v_48]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { match __v_12.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_13, __v_1, __v_48]; 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_580] = { let __args: [G; IN_580] = [__v_13, __v_1, __v_48]; 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_49: G = __r_arr[0]; - let __ret: [G; OUT_571] = [__v_49]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_579] = [__v_49]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); - let __ret: [G; OUT_571] = [__v_48]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_579] = [__v_48]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49720,23 +50361,23 @@ fn aiur_fn_571( }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_571] = [__v_14]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_579] = [__v_14]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_572: usize = 3; -const IN_572: usize = 3; -const OUT_572: usize = 1; -fn aiur_fn_572( - inp: [G; IN_572], +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_572], 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]; @@ -49748,8 +50389,8 @@ fn aiur_fn_572( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_6]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_580] = [__v_6]; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -49774,16 +50415,16 @@ fn aiur_fn_572( 0u64 => { let __v_19: G = G::from_u64(1); let __v_20: G = (__v_2 + __v_19); - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_0, __v_5, __v_20]; 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_580] = { let __args: [G; IN_580] = [__v_0, __v_5, __v_20]; 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_21: G = __r_arr[0]; - let __ret: [G; OUT_572] = [__v_21]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_580] = [__v_21]; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_572] = [__v_19]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_580] = [__v_19]; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49791,10 +50432,10 @@ fn aiur_fn_572( _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_2 + __v_17); - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_0, __v_5, __v_18]; 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_580] = { let __args: [G; IN_580] = [__v_0, __v_5, __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_572] = [__v_19]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_580] = [__v_19]; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49806,20 +50447,20 @@ fn aiur_fn_572( }) } -const INPUT_SIZE_573: usize = 3; -const IN_573: usize = 3; -const OUT_573: usize = 1; -fn aiur_fn_573( - inp: [G; IN_573], +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_573], ExecError> { +) -> Result<[G; OUT_581], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __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_3: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -49835,33 +50476,33 @@ fn aiur_fn_573( let __v_14: G = __loaded[10]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_9, __v_7, __v_1, __v_2]; 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_582] = { let __args: [G; IN_582] = [__v_9, __v_7, __v_1, __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_15: G = __r_arr[0]; - let __ret: [G; OUT_573] = [__v_15]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_581] = [__v_15]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 5] = [__v_15, __v_16, __v_16, __v_16, __v_16]; 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_573] = [__v_17]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_581] = [__v_17]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_574: usize = 4; -const IN_574: usize = 4; -const OUT_574: usize = 1; -fn aiur_fn_574( - inp: [G; IN_574], +const INPUT_SIZE_582: usize = 4; +const IN_582: usize = 4; +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_574], 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]; @@ -49876,12 +50517,12 @@ fn aiur_fn_574( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 5] = [__v_7, __v_8, __v_8, __v_8, __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_574] = [__v_9]; - record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_9]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_5]; 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_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -49899,21 +50540,21 @@ fn aiur_fn_574( 6u64 => { let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_10, __v_1]; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_19, __v_2, __v_3]; 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_583] = { let __args: [G; IN_583] = [__v_19, __v_2, __v_3]; 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_20: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_6, __v_1, __v_2, __v_3]; 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_582] = { let __args: [G; IN_582] = [__v_6, __v_1, __v_2, __v_3]; 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_21: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_20, __v_21]; 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_722] = { let __args: [G; IN_722] = [__v_20, __v_21]; 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_22: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_22]; - record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_22]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_6, __v_1, __v_2, __v_3]; 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_582] = { let __args: [G; IN_582] = [__v_6, __v_1, __v_2, __v_3]; 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_19: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_19]; - record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_19]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49925,15 +50566,15 @@ fn aiur_fn_574( }) } -const INPUT_SIZE_575: usize = 3; -const IN_575: usize = 3; -const OUT_575: usize = 1; -fn aiur_fn_575( - inp: [G; IN_575], +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_575], 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]; @@ -49945,42 +50586,42 @@ fn aiur_fn_575( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_1, __v_2]; 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_584] = { let __args: [G; IN_584] = [__v_4, __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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_5, __v_1, __v_2]; 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_583] = { let __args: [G; IN_583] = [__v_5, __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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_7, __v_8]; 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_722] = { let __args: [G; IN_722] = [__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_9: G = __r_arr[0]; - let __ret: [G; OUT_575] = [__v_9]; - record.function_queries[575].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)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 5] = [__v_7, __v_8, __v_8, __v_8, __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_575] = [__v_9]; - record.function_queries[575].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)); return Ok(__ret); }, } }) } -const INPUT_SIZE_576: usize = 3; -const IN_576: usize = 3; -const OUT_576: usize = 1; -fn aiur_fn_576( - inp: [G; IN_576], +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_576], ExecError> { +) -> Result<[G; OUT_584], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0]; 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_536] = { let __args: [G; IN_536] = [__v_0]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; @@ -50000,12 +50641,12 @@ fn aiur_fn_576( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 5] = [__v_12, __v_13, __v_13, __v_13, __v_13]; 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_576] = [__v_14]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_14]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_8]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_8]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -50029,12 +50670,12 @@ fn aiur_fn_576( let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 5] = [__v_26, __v_27, __v_27, __v_27, __v_27]; 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_576] = [__v_28]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_28]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_6, __v_16]; 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_738] = { let __args: [G; IN_738] = [__v_6, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_26, __v_1]; 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_27: G = __r_arr[0]; @@ -50043,8 +50684,8 @@ fn aiur_fn_576( let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 5] = [__v_28, __v_29, __v_29, __v_29, __v_29]; 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_576] = [__v_30]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_30]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -50053,8 +50694,8 @@ fn aiur_fn_576( let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 5] = [__v_29, __v_30, __v_30, __v_30, __v_30]; 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_32: G = { let __values: [G; 5] = [__v_28, __v_8, __v_26, __v_9, __v_31]; 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_576] = [__v_32]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_32]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50071,8 +50712,8 @@ fn aiur_fn_576( let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 5] = [__v_24, __v_25, __v_25, __v_25, __v_25]; 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_576] = [__v_26]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_26]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50086,45 +50727,45 @@ fn aiur_fn_576( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 5] = [__v_11, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_576] = [__v_13]; - record.function_queries[576].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)); return Ok(__ret); }, } }) } -const INPUT_SIZE_577: usize = 3; -const IN_577: usize = 3; -const OUT_577: usize = 1; -fn aiur_fn_577( - inp: [G; IN_577], +const INPUT_SIZE_585: usize = 3; +const IN_585: usize = 3; +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_577], ExecError> { +) -> Result<[G; OUT_585], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_0, __v_1, __v_2, __v_3]; 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_586] = { let __args: [G; IN_586] = [__v_0, __v_1, __v_2, __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_4: G = __r_arr[0]; - let __ret: [G; OUT_577] = [__v_4]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_4]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_578: usize = 4; -const IN_578: usize = 4; -const OUT_578: usize = 1; -fn aiur_fn_578( - inp: [G; IN_578], +const INPUT_SIZE_586: usize = 4; +const IN_586: usize = 4; +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_578], 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]; @@ -50132,8 +50773,8 @@ fn aiur_fn_578( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_578] = [__v_0]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_0]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50144,7 +50785,7 @@ fn aiur_fn_578( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __v_3]; 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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_6, __v_8, __v_9]; 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)? } }; @@ -50153,10 +50794,10 @@ fn aiur_fn_578( let __v_12: G = (__v_1 - __v_11); let __v_13: G = G::from_u64(1); let __v_14: G = (__v_3 + __v_13); - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_10, __v_12, __v_2, __v_14]; 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_586] = { let __args: [G; IN_586] = [__v_10, __v_12, __v_2, __v_14]; 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_15: G = __r_arr[0]; - let __ret: [G; OUT_578] = [__v_15]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_586] = [__v_15]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50168,39 +50809,39 @@ fn aiur_fn_578( }) } -const INPUT_SIZE_579: usize = 2; -const IN_579: usize = 2; -const OUT_579: usize = 0; -fn aiur_fn_579( - inp: [G; IN_579], +const INPUT_SIZE_587: usize = 2; +const IN_587: usize = 2; +const OUT_587: usize = 0; +fn aiur_fn_587( + inp: [G; IN_587], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_579], 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]; - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_0, __v_1]; 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_589] = { let __args: [G; IN_589] = [__v_0, __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_2: G = __r_arr[0]; - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __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_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 __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_2, __v_3, __v_4, __v_1]; 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 __ret: [G; OUT_579] = []; - record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_2, __v_3, __v_4, __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 __ret: [G; OUT_587] = []; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_580: usize = 2; -const IN_580: usize = 2; -const OUT_580: usize = 2; -fn aiur_fn_580( - inp: [G; IN_580], +const INPUT_SIZE_588: usize = 2; +const IN_588: usize = 2; +const OUT_588: usize = 2; +fn aiur_fn_588( + inp: [G; IN_588], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_580], 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]; @@ -50214,24 +50855,24 @@ fn aiur_fn_580( 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_580] = [__v_5, __v_8]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_588] = [__v_5, __v_8]; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_3, __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_579] = { let __args: [G; IN_579] = [__v_3, __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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - 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_588] = { let __args: [G; IN_588] = [__v_4, __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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_580] = [__v_6, __v_7]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_588] = [__v_6, __v_7]; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_6: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -50247,19 +50888,19 @@ fn aiur_fn_580( let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_9, __v_10]; 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_541] = { let __args: [G; IN_541] = [__v_9, __v_10]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_580] = [__v_10, __v_18]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_588] = [__v_10, __v_18]; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - 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_588] = { let __args: [G; IN_588] = [__v_4, __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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_580] = [__v_18, __v_19]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_588] = [__v_18, __v_19]; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50276,15 +50917,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_589: usize = 3; +const IN_589: usize = 3; +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_581], 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]; @@ -50298,30 +50939,30 @@ fn aiur_fn_581( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 5] = [__v_6, __v_7, __v_7, __v_7, __v_7]; 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_581] = [__v_8]; - record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_8]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_4, __v_2]; 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_579] = { let __args: [G; IN_579] = [__v_4, __v_2]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_1, __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_589] = { let __args: [G; IN_589] = [__v_5, __v_1, __v_2]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_581] = [__v_7]; - record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_7]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4, __v_1, __v_2]; 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_581] = { let __args: [G; IN_581] = [__v_4, __v_1, __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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_1, __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_589] = { let __args: [G; IN_589] = [__v_5, __v_1, __v_2]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_7, __v_8]; 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_722] = { let __args: [G; IN_722] = [__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_9: G = __r_arr[0]; - let __ret: [G; OUT_581] = [__v_9]; - record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_9]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50336,15 +50977,15 @@ fn aiur_fn_581( }) } -const INPUT_SIZE_582: usize = 5; -const IN_582: usize = 5; -const OUT_582: usize = 0; -fn aiur_fn_582( - inp: [G; IN_582], +const INPUT_SIZE_590: usize = 5; +const IN_590: usize = 5; +const OUT_590: usize = 0; +fn aiur_fn_590( + inp: [G; IN_590], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_582], 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]; @@ -50357,22 +50998,22 @@ fn aiur_fn_582( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_582] = []; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_590] = []; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_6, __v_4]; 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_579] = { let __args: [G; IN_579] = [__v_6, __v_4]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_582] = []; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2, __v_3, __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 __ret: [G; OUT_590] = []; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __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_726] = { let __args: [G; IN_726] = [__v_4, __v_6]; 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_9: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -50388,21 +51029,21 @@ fn aiur_fn_582( let __v_20: G = __loaded[10]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_12, __v_15, __v_1, __v_2, __v_3, __v_4]; 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_591] = { let __args: [G; IN_591] = [__v_12, __v_15, __v_1, __v_2, __v_3, __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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); } - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_582] = []; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2, __v_3, __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 __ret: [G; OUT_590] = []; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_582] = []; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2, __v_3, __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 __ret: [G; OUT_590] = []; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50419,15 +51060,15 @@ fn aiur_fn_582( }) } -const INPUT_SIZE_583: usize = 6; -const IN_583: usize = 6; -const OUT_583: usize = 1; -fn aiur_fn_583( - inp: [G; IN_583], +const INPUT_SIZE_591: usize = 6; +const IN_591: usize = 6; +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_583], 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]; @@ -50444,12 +51085,12 @@ fn aiur_fn_583( match __v_6.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_583] = [__v_11]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_11]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __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_726] = { let __args: [G; IN_726] = [__v_5, __v_7]; 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_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -50465,11 +51106,11 @@ fn aiur_fn_583( let __v_22: G = __loaded[10]; match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_14, __v_15, __v_8]; 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_585] = { let __args: [G; IN_585] = [__v_14, __v_15, __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_23: G = __r_arr[0]; let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_23, __v_4]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_24, __v_0]; 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_613] = { let __args: [G; IN_613] = [__v_24, __v_0]; 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_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { @@ -50480,47 +51121,47 @@ fn aiur_fn_583( let __v_28: G = (__v_26 - __v_27); match __v_28.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_1, __v_17, __v_15, __v_8, __v_4, __v_5]; 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_592] = { let __args: [G; IN_592] = [__v_1, __v_17, __v_15, __v_8, __v_4, __v_5]; 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_29: G = __r_arr[0]; match __v_29.as_canonical_u64() { 1u64 => { let __v_30: G = G::from_u64(1); - let __ret: [G; OUT_583] = [__v_30]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_30]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_30: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_30]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_30]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_29: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_29]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_29]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_26: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_26]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_26]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_23: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_23]; - record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_23]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50532,15 +51173,15 @@ fn aiur_fn_583( }) } -const INPUT_SIZE_584: usize = 6; -const IN_584: usize = 6; -const OUT_584: usize = 1; -fn aiur_fn_584( - inp: [G; IN_584], +const INPUT_SIZE_592: usize = 6; +const IN_592: usize = 6; +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_584], 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]; @@ -50561,14 +51202,14 @@ fn aiur_fn_584( match __v_9.as_canonical_u64() { 1u64 => { 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_592] = [__v_12]; + record.function_queries[592].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_592] = [__v_12]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50581,12 +51222,12 @@ fn aiur_fn_584( match __v_9.as_canonical_u64() { 1u64 => { 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_592] = [__v_12]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __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_726] = { let __args: [G; IN_726] = [__v_5, __v_7]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -50600,7 +51241,7 @@ fn aiur_fn_584( let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; let __v_23: G = __loaded[10]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __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_726] = { let __args: [G; IN_726] = [__v_5, __v_10]; 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_24: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -50618,40 +51259,40 @@ fn aiur_fn_584( 6u64 => { match __v_25.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_27, __v_2, __v_3]; 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_585] = { let __args: [G; IN_585] = [__v_27, __v_2, __v_3]; 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_36: G = __r_arr[0]; let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_36, __v_4]; 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_37: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_37, __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_613] = { let __args: [G; IN_613] = [__v_37, __v_15]; 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_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_8, __v_11, __v_2, __v_3, __v_4, __v_5]; 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_592] = { let __args: [G; IN_592] = [__v_8, __v_11, __v_2, __v_3, __v_4, __v_5]; 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_39: G = __r_arr[0]; - let __ret: [G; OUT_584] = [__v_39]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_39]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_39]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_39]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_36]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_36]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_584] = [__v_36]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_36]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50668,15 +51309,15 @@ fn aiur_fn_584( }) } -const INPUT_SIZE_585: usize = 20; -const IN_585: usize = 20; -const OUT_585: usize = 1; -fn aiur_fn_585( - inp: [G; IN_585], +const INPUT_SIZE_593: usize = 21; +const IN_593: usize = 21; +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_585], 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]; @@ -50698,69 +51339,70 @@ fn aiur_fn_585( let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; + let __v_20: G = inp[20]; let __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_20: G = __loaded[0]; - let __v_21: G = __loaded[1]; - let __v_22: G = __loaded[2]; - match __v_20.as_canonical_u64() { + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + match __v_21.as_canonical_u64() { 1u64 => { - let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 5] = [__v_23, __v_24, __v_24, __v_24, __v_24]; 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_585] = [__v_25]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_25: G = G::from_u64(1); + let __v_26: G = { let __values: [G; 5] = [__v_24, __v_25, __v_25, __v_25, __v_25]; 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_593] = [__v_26]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_17, __v_21]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; - let __v_24: G = __loaded[0]; - let __v_25: G = __loaded[1]; - let __v_26: G = __loaded[2]; - let __v_27: G = __loaded[3]; - let __v_28: G = __loaded[4]; - let __v_29: G = __loaded[5]; - let __v_30: G = __loaded[6]; - let __v_31: G = __loaded[7]; - let __v_32: G = __loaded[8]; - let __v_33: G = __loaded[9]; - let __v_34: G = __loaded[10]; - match __v_24.as_canonical_u64() { + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_18, __v_22]; 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_24: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_25: G = __loaded[0]; + let __v_26: G = __loaded[1]; + let __v_27: G = __loaded[2]; + let __v_28: G = __loaded[3]; + let __v_29: G = __loaded[4]; + let __v_30: G = __loaded[5]; + let __v_31: G = __loaded[6]; + let __v_32: G = __loaded[7]; + let __v_33: G = __loaded[8]; + let __v_34: G = __loaded[9]; + let __v_35: G = __loaded[10]; + match __v_25.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_0, __v_27, __v_21, __v_26, __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]; 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 = __r_arr[0]; - let __v_36: G = G::from_u64(0); - let __v_37: G = G::from_u64(1); - let __v_38: G = (__v_19 + __v_37); - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_0, __v_1, __v_22, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_38]; 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_39: G = __r_arr[0]; - let __v_40: G = { let __values: [G; 5] = [__v_36, __v_21, __v_30, __v_35, __v_39]; 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_585] = [__v_40]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_28, __v_22, __v_27, __v_20, __v_3, __v_4, __v_5, __v_6, __v_7, __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[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_36: G = __r_arr[0]; + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(1); + let __v_39: G = (__v_20 + __v_38); + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_1, __v_23, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_39]; 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_40: G = __r_arr[0]; + let __v_41: G = { let __values: [G; 5] = [__v_37, __v_22, __v_31, __v_36, __v_40]; 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_593] = [__v_41]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); }, } }) } -const INPUT_SIZE_586: usize = 11; -const IN_586: usize = 11; -const OUT_586: usize = 1; -fn aiur_fn_586( - inp: [G; IN_586], +const INPUT_SIZE_594: usize = 11; +const IN_594: usize = 11; +const OUT_594: usize = 1; +fn aiur_fn_594( + inp: [G; IN_594], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_586], 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]; @@ -50782,18 +51424,18 @@ fn aiur_fn_586( 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_586] = [__v_16]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_16]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_10]; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = (__v_5 + __v_10); let __v_17: G = (__v_6 + __v_16); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_12]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_12]; 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_18: G = __r_arr[0]; let __v_19: G = (__v_5 - __v_12); let __v_20: G = (__v_19 + __v_10); @@ -50802,12 +51444,12 @@ fn aiur_fn_586( let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_22, __v_7, __v_8, __v_9]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_23]; 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_536] = { let __args: [G; IN_536] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24]; 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_724] = { let __args: [G; IN_724] = [__v_24]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_26, __v_7]; 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_721] = { let __args: [G; IN_721] = [__v_26, __v_7]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_25, __v_27, __v_8, __v_9]; 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_28: G = __r_arr[0]; @@ -50825,7 +51467,7 @@ fn aiur_fn_586( let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_40, __v_15]; 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_741] = { let __args: [G; IN_741] = [__v_40, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); @@ -50846,11 +51488,11 @@ fn aiur_fn_586( let __v_55: G = G::from_u64(0); let __v_56: G = G::from_u64(1); let __v_57: G = (__v_10 + __v_56); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_57]; 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_594] = { let __args: [G; IN_594] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_57]; 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_58: G = __r_arr[0]; let __v_59: G = { let __values: [G; 3] = [__v_55, __v_54, __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_586] = [__v_59]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_59]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50860,15 +51502,15 @@ fn aiur_fn_586( }) } -const INPUT_SIZE_587: usize = 7; -const IN_587: usize = 7; -const OUT_587: usize = 0; -fn aiur_fn_587( - inp: [G; IN_587], +const INPUT_SIZE_595: usize = 7; +const IN_595: usize = 7; +const OUT_595: usize = 0; +fn aiur_fn_595( + inp: [G; IN_595], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_587], 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]; @@ -50914,15 +51556,15 @@ fn aiur_fn_587( let __v_40: G = __r_arr[0]; match __v_40.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_587] = []; - record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = []; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_41: G = G::from_u64(0); - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_6, __v_41]; 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 __ret: [G; OUT_587] = []; - record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_6, __v_41]; 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 __ret: [G; OUT_595] = []; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50932,15 +51574,15 @@ fn aiur_fn_587( }) } -const INPUT_SIZE_588: usize = 9; -const IN_588: usize = 9; -const OUT_588: usize = 0; -fn aiur_fn_588( - inp: [G; IN_588], +const INPUT_SIZE_596: usize = 9; +const IN_596: usize = 9; +const OUT_596: usize = 0; +fn aiur_fn_596( + inp: [G; IN_596], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_588], 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]; @@ -50957,8 +51599,8 @@ fn aiur_fn_588( let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_588] = []; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_596] = []; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -50988,7 +51630,7 @@ fn aiur_fn_588( if (__v_15 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); } - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_1, __v_14, __v_2, __v_6, __v_7]; 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_597] = { let __args: [G; IN_597] = [__v_1, __v_14, __v_2, __v_6, __v_7]; 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_29: G = (__v_2 + __v_3); let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1, __v_29]; 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_30: G = __r_arr[0]; @@ -51003,17 +51645,17 @@ fn aiur_fn_588( } let __v_35: G = G::from_u64(1); let __v_36: G = (__v_8 + __v_35); - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_36]; 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 __ret: [G; OUT_588] = []; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_36]; 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 __ret: [G; OUT_596] = []; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_29: G = G::from_u64(1); let __v_30: G = (__v_8 + __v_29); - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_30]; 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 __ret: [G; OUT_588] = []; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_30]; 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 __ret: [G; OUT_596] = []; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51024,9 +51666,9 @@ fn aiur_fn_588( _ => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_8 + __v_23); - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_24]; 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 __ret: [G; OUT_588] = []; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_24]; 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 __ret: [G; OUT_596] = []; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51038,15 +51680,15 @@ fn aiur_fn_588( }) } -const INPUT_SIZE_589: usize = 5; -const IN_589: usize = 5; -const OUT_589: usize = 0; -fn aiur_fn_589( - inp: [G; IN_589], +const INPUT_SIZE_597: usize = 5; +const IN_597: usize = 5; +const OUT_597: usize = 0; +fn aiur_fn_597( + inp: [G; IN_597], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_589], 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]; @@ -51056,22 +51698,22 @@ fn aiur_fn_589( 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_590] = { let __args: [G; IN_590] = [__v_0, __v_1, __v_2, __v_7, __v_3, __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 __ret: [G; OUT_589] = []; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; 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 __ret: [G; OUT_597] = []; + record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_590: usize = 6; -const IN_590: usize = 6; -const OUT_590: usize = 0; -fn aiur_fn_590( - inp: [G; IN_590], +const INPUT_SIZE_598: usize = 6; +const IN_598: usize = 6; +const OUT_598: usize = 0; +fn aiur_fn_598( + inp: [G; IN_598], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_590], 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]; @@ -51081,8 +51723,8 @@ fn aiur_fn_590( let __v_5: G = inp[5]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_590] = []; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_598] = []; + record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51110,9 +51752,9 @@ fn aiur_fn_590( let __v_17: G = { let __values: [G; 3] = [__v_16, __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_18: G = G::from_u64(1); let __v_19: G = (__v_2 - __v_18); - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_8, __v_12, __v_19, __v_17, __v_4, __v_5]; 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 __ret: [G; OUT_590] = []; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_8, __v_12, __v_19, __v_17, __v_4, __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 __ret: [G; OUT_598] = []; + record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51129,15 +51771,15 @@ fn aiur_fn_590( }) } -const INPUT_SIZE_591: usize = 2; -const IN_591: usize = 2; -const OUT_591: usize = 1; -fn aiur_fn_591( - inp: [G; IN_591], +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_591], 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]; @@ -51145,8 +51787,8 @@ fn aiur_fn_591( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_591] = [__v_3]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_599] = [__v_3]; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51154,14 +51796,14 @@ fn aiur_fn_591( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_591] = [__v_4]; - record.function_queries[591].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); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_591] = [__v_4]; - record.function_queries[591].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); }, _ => { @@ -51173,132 +51815,132 @@ fn aiur_fn_591( }) } -const INPUT_SIZE_592: usize = 2; -const IN_592: usize = 2; -const OUT_592: usize = 1; -fn aiur_fn_592( - inp: [G; IN_592], +const INPUT_SIZE_600: usize = 2; +const IN_600: usize = 2; +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_592], 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]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_592] = [__v_1]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_600] = [__v_1]; + record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_592] = [__v_0]; - record.function_queries[592].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); }, } }) } -const INPUT_SIZE_593: usize = 0; -const IN_593: usize = 0; -const OUT_593: usize = 2; -fn aiur_fn_593( - inp: [G; IN_593], +const INPUT_SIZE_601: usize = 0; +const IN_601: usize = 0; +const OUT_601: usize = 2; +fn aiur_fn_601( + inp: [G; IN_601], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_593], ExecError> { +) -> Result<[G; OUT_601], 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_593] = [__v_0, __v_1]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_601] = [__v_0, __v_1]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_594: usize = 0; -const IN_594: usize = 0; -const OUT_594: usize = 2; -fn aiur_fn_594( - inp: [G; IN_594], +const INPUT_SIZE_602: usize = 0; +const IN_602: usize = 0; +const OUT_602: usize = 2; +fn aiur_fn_602( + inp: [G; IN_602], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_594], ExecError> { +) -> Result<[G; OUT_602], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_594] = [__v_0, __v_1]; - record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_602] = [__v_0, __v_1]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_595: usize = 0; -const IN_595: usize = 0; -const OUT_595: usize = 2; -fn aiur_fn_595( - inp: [G; IN_595], +const INPUT_SIZE_603: usize = 0; +const IN_603: usize = 0; +const OUT_603: usize = 2; +fn aiur_fn_603( + inp: [G; IN_603], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_595], ExecError> { +) -> Result<[G; OUT_603], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(1); let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_595] = [__v_0, __v_1]; - record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_603] = [__v_0, __v_1]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_596: usize = 0; -const IN_596: usize = 0; -const OUT_596: usize = 2; -fn aiur_fn_596( - inp: [G; IN_596], +const INPUT_SIZE_604: usize = 0; +const IN_604: usize = 0; +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_596], ExecError> { +) -> Result<[G; OUT_604], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(1); let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_596] = [__v_0, __v_1]; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_604] = [__v_0, __v_1]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_597: usize = 0; -const IN_597: usize = 0; -const OUT_597: usize = 2; -fn aiur_fn_597( - inp: [G; IN_597], +const INPUT_SIZE_605: usize = 0; +const IN_605: usize = 0; +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_597], ExecError> { +) -> Result<[G; OUT_605], 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_597] = [__v_0, __v_1]; - record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_605] = [__v_0, __v_1]; + record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_598: usize = 4; -const IN_598: usize = 4; -const OUT_598: usize = 2; -fn aiur_fn_598( - inp: [G; IN_598], +const INPUT_SIZE_606: usize = 4; +const IN_606: usize = 4; +const OUT_606: usize = 2; +fn aiur_fn_606( + inp: [G; IN_606], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_598], 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]; @@ -51307,46 +51949,46 @@ fn aiur_fn_598( match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); - let __ret: [G; OUT_598] = [__v_2, __v_4]; - record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_606] = [__v_2, __v_4]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_598] = [__v_0, __v_1]; - record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_606] = [__v_0, __v_1]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_599: usize = 1; -const IN_599: usize = 1; -const OUT_599: usize = 2; -fn aiur_fn_599( - inp: [G; IN_599], +const INPUT_SIZE_607: usize = 1; +const IN_607: usize = 1; +const OUT_607: usize = 2; +fn aiur_fn_607( + inp: [G; IN_607], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_599], ExecError> { +) -> Result<[G; OUT_607], 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_599] = [__v_0, __v_1]; - record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_607] = [__v_0, __v_1]; + record.function_queries[607].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_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_600], 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]; @@ -51358,8 +52000,8 @@ fn aiur_fn_600( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_600] = [__v_6]; - record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_608] = [__v_6]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -51368,17 +52010,17 @@ fn aiur_fn_600( 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_2); - let __ret: [G; OUT_600] = [__v_8]; - record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_608] = [__v_8]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_5, __v_8]; 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_608] = { let __args: [G; IN_608] = [__v_0, __v_5, __v_8]; 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_9: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_9]; - record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_608] = [__v_9]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51390,44 +52032,44 @@ fn aiur_fn_600( }) } -const INPUT_SIZE_601: usize = 3; -const IN_601: usize = 3; -const OUT_601: usize = 2; -fn aiur_fn_601( - inp: [G; IN_601], +const INPUT_SIZE_609: usize = 3; +const IN_609: usize = 3; +const OUT_609: usize = 2; +fn aiur_fn_609( + inp: [G; IN_609], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_601], 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_600] = { let __args: [G; IN_600] = [__v_0, __v_2, __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_608] = { let __args: [G; IN_608] = [__v_0, __v_2, __v_3]; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__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_608] = { let __args: [G; IN_608] = [__v_1, __v_2, __v_5]; 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_6: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1]; 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_599] = { let __args: [G; IN_599] = [__v_0, __v_1]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7]; 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_607] = { let __args: [G; IN_607] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_601] = [__v_8, __v_9]; - record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_609] = [__v_8, __v_9]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_601] = [__v_7, __v_8]; - record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_609] = [__v_7, __v_8]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51435,19 +52077,19 @@ fn aiur_fn_601( _ => { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; 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_601] = { let __args: [G; IN_601] = []; 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 __v_8: G = __r_arr[1]; - let __ret: [G; OUT_601] = [__v_7, __v_8]; - record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_609] = [__v_7, __v_8]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_6]; 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_599] = { let __args: [G; IN_599] = [__v_4, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_601] = [__v_7, __v_8]; - record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_609] = [__v_7, __v_8]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51456,15 +52098,15 @@ fn aiur_fn_601( }) } -const INPUT_SIZE_602: usize = 2; -const IN_602: usize = 2; -const OUT_602: usize = 1; -fn aiur_fn_602( - inp: [G; IN_602], +const INPUT_SIZE_610: usize = 2; +const IN_610: usize = 2; +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_602], 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]; @@ -51481,14 +52123,14 @@ fn aiur_fn_602( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51501,21 +52143,21 @@ fn aiur_fn_602( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_3, __v_6]; 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_610] = { let __args: [G; IN_610] = [__v_3, __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_8: G = __r_arr[0]; - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51528,31 +52170,31 @@ fn aiur_fn_602( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_3, __v_6]; 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_610] = { let __args: [G; IN_610] = [__v_3, __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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_4, __v_7]; 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_610] = { let __args: [G; IN_610] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_9]; 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_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_602] = [__v_10]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_10]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51565,37 +52207,37 @@ fn aiur_fn_602( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_3, __v_6]; 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_610] = { let __args: [G; IN_610] = [__v_3, __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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_4, __v_7]; 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_610] = { let __args: [G; IN_610] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_9]; 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_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_602] = [__v_10]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_10]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51610,16 +52252,16 @@ fn aiur_fn_602( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_6]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_602] = [__v_8]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_8]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51631,15 +52273,15 @@ fn aiur_fn_602( }) } -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_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_603], 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]; @@ -51656,14 +52298,14 @@ fn aiur_fn_603( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_603] = [__v_8]; - record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_611] = [__v_8]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_603] = [__v_8]; - record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_611] = [__v_8]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51676,19 +52318,19 @@ fn aiur_fn_603( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_603] = [__v_8]; - record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_611] = [__v_8]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_3, __v_6]; 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_610] = { let __args: [G; IN_610] = [__v_3, __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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_4, __v_7]; 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_611] = { let __args: [G; IN_611] = [__v_4, __v_7]; 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 __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_9]; 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_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_603] = [__v_10]; - record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_611] = [__v_10]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51703,38 +52345,38 @@ 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_612: usize = 2; +const IN_612: usize = 2; +const OUT_612: usize = 2; +fn aiur_fn_612( + inp: [G; IN_612], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_604], ExecError> { +) -> Result<[G; OUT_612], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_1]; 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_611] = { let __args: [G; IN_611] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2]; 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_607] = { let __args: [G; IN_607] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_604] = [__v_3, __v_4]; - record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_612] = [__v_3, __v_4]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_605: usize = 2; -const IN_605: usize = 2; -const OUT_605: usize = 1; -fn aiur_fn_605( - inp: [G; IN_605], +const INPUT_SIZE_613: usize = 2; +const IN_613: usize = 2; +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_605], 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]; @@ -51742,8 +52384,8 @@ fn aiur_fn_605( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_605] = [__v_3]; - record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_3]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51757,25 +52399,25 @@ fn aiur_fn_605( let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__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[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_614] = { let __args: [G; IN_614] = [__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[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_11: G = __r_arr[0]; - let __ret: [G; OUT_605] = [__v_11]; - record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_11]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_606: usize = 8; -const IN_606: usize = 8; -const OUT_606: usize = 1; -fn aiur_fn_606( - inp: [G; IN_606], +const INPUT_SIZE_614: usize = 8; +const IN_614: usize = 8; +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_606], 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]; @@ -51789,16 +52431,16 @@ fn aiur_fn_606( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_5]; 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_599] = { let __args: [G; IN_599] = [__v_1, __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_8: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51807,21 +52449,21 @@ fn aiur_fn_606( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_1, __v_5]; 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_610] = { let __args: [G; IN_610] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51830,31 +52472,31 @@ fn aiur_fn_606( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_5]; 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_599] = { let __args: [G; IN_599] = [__v_1, __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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_2, __v_6]; 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_611] = { let __args: [G; IN_611] = [__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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_9]; 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_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_10]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_10]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51863,37 +52505,37 @@ fn aiur_fn_606( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_1, __v_5]; 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_613] = { let __args: [G; IN_613] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_6]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_9]; 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_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_10]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_10]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51902,43 +52544,43 @@ fn aiur_fn_606( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_1, __v_5]; 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_613] = { let __args: [G; IN_613] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_6]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_9]; 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_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_10]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_10]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51947,49 +52589,49 @@ fn aiur_fn_606( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_1, __v_5]; 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_613] = { let __args: [G; IN_613] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_6]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_9]; 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_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_10]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_10]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51998,59 +52640,59 @@ fn aiur_fn_606( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_1, __v_5]; 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_613] = { let __args: [G; IN_613] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_6]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_3, __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_613] = { let __args: [G; IN_613] = [__v_3, __v_7]; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_9, __v_10]; 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_600] = { let __args: [G; IN_600] = [__v_9, __v_10]; 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 __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_11]; 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_600] = { let __args: [G; IN_600] = [__v_8, __v_11]; 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_12: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_12]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_12]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52059,21 +52701,21 @@ fn aiur_fn_606( match __v_4.as_canonical_u64() { 8u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_1, __v_2, __v_5, __v_6]; 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_617] = { let __args: [G; IN_617] = [__v_1, __v_2, __v_5, __v_6]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52081,24 +52723,24 @@ fn aiur_fn_606( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_5]; 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_599] = { let __args: [G; IN_599] = [__v_1, __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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_6]; 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_599] = { let __args: [G; IN_599] = [__v_2, __v_6]; 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 __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_3, __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_613] = { let __args: [G; IN_613] = [__v_3, __v_7]; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_9, __v_10]; 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_600] = { let __args: [G; IN_600] = [__v_9, __v_10]; 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 __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_11]; 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_600] = { let __args: [G; IN_600] = [__v_8, __v_11]; 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_12: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_12]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_12]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_606] = [__v_8]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52110,15 +52752,15 @@ fn aiur_fn_606( }) } -const INPUT_SIZE_607: usize = 3; -const IN_607: usize = 3; -const OUT_607: usize = 2; -fn aiur_fn_607( - inp: [G; IN_607], +const INPUT_SIZE_615: usize = 3; +const IN_615: usize = 3; +const OUT_615: usize = 2; +fn aiur_fn_615( + inp: [G; IN_615], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_607], 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]; @@ -52126,11 +52768,11 @@ fn aiur_fn_607( let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = []; 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_603] = { let __args: [G; IN_603] = []; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_607] = [__v_4, __v_5]; - record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_615] = [__v_4, __v_5]; + record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52144,26 +52786,26 @@ fn aiur_fn_607( let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__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[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_616] = { let __args: [G; IN_616] = [__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[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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_607] = [__v_12, __v_13]; - record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_615] = [__v_12, __v_13]; + record.function_queries[615].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 = 2; -fn aiur_fn_608( - inp: [G; IN_608], +const INPUT_SIZE_616: usize = 9; +const IN_616: usize = 9; +const OUT_616: usize = 2; +fn aiur_fn_616( + inp: [G; IN_616], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_608], 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]; @@ -52178,21 +52820,21 @@ fn aiur_fn_608( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_5]; 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_599] = { let __args: [G; IN_599] = [__v_1, __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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9]; 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_607] = { let __args: [G; IN_607] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_10, __v_11]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_10, __v_11]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; 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_601] = { let __args: [G; IN_601] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52200,29 +52842,29 @@ fn aiur_fn_608( 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_1, __v_5]; 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_610] = { let __args: [G; IN_610] = [__v_1, __v_5]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9]; 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_607] = { let __args: [G; IN_607] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_10, __v_11]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_10, __v_11]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; 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_601] = { let __args: [G; IN_601] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52230,41 +52872,41 @@ fn aiur_fn_608( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6]; 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_612] = { let __args: [G; IN_612] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_1, __v_5, __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_609] = { let __args: [G; IN_609] = [__v_1, __v_5, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_9, __v_10, __v_11, __v_12]; 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_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_13, __v_14]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_13, __v_14]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; 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_601] = { let __args: [G; IN_601] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52272,49 +52914,49 @@ fn aiur_fn_608( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_1, __v_5, __v_8]; 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_615] = { let __args: [G; IN_615] = [__v_1, __v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_6, __v_8]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_6, __v_8]; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_9, __v_10, __v_11, __v_12]; 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_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_13, __v_14]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_13, __v_14]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; 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_601] = { let __args: [G; IN_601] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52322,57 +52964,57 @@ fn aiur_fn_608( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_1, __v_5, __v_8]; 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_615] = { let __args: [G; IN_615] = [__v_1, __v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_6, __v_8]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_6, __v_8]; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_9, __v_10, __v_11, __v_12]; 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_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_13, __v_14]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_13, __v_14]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; 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_601] = { let __args: [G; IN_601] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52380,65 +53022,65 @@ fn aiur_fn_608( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_1, __v_5, __v_8]; 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_615] = { let __args: [G; IN_615] = [__v_1, __v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_6, __v_8]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_6, __v_8]; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_9, __v_10, __v_11, __v_12]; 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_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_13, __v_14]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_13, __v_14]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; 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_601] = { let __args: [G; IN_601] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52446,79 +53088,79 @@ fn aiur_fn_608( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_1, __v_5, __v_8]; 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_615] = { let __args: [G; IN_615] = [__v_1, __v_5, __v_8]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_6, __v_8]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_6, __v_8]; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_3, __v_7, __v_8]; 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_615] = { let __args: [G; IN_615] = [__v_3, __v_7, __v_8]; 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 __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_12, __v_13, __v_14]; 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_606] = { let __args: [G; IN_606] = [__v_11, __v_12, __v_13, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_9, __v_10, __v_15, __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_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_15, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_17, __v_18]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_17, __v_18]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; 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_601] = { let __args: [G; IN_601] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52526,29 +53168,29 @@ fn aiur_fn_608( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; 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_601] = { let __args: [G; IN_601] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_1, __v_2, __v_5, __v_6]; 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_617] = { let __args: [G; IN_617] = [__v_1, __v_2, __v_5, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9]; 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_607] = { let __args: [G; IN_607] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_10, __v_11]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_10, __v_11]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52556,33 +53198,33 @@ fn aiur_fn_608( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_1, __v_5, __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_609] = { let __args: [G; IN_609] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_6]; 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_599] = { let __args: [G; IN_599] = [__v_2, __v_6]; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11]; 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_607] = { let __args: [G; IN_607] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_3, __v_7, __v_8]; 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_615] = { let __args: [G; IN_615] = [__v_3, __v_7, __v_8]; 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 __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_12, __v_13, __v_14, __v_15]; 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_606] = { let __args: [G; IN_606] = [__v_12, __v_13, __v_14, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_9, __v_10, __v_16, __v_17]; 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_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_16, __v_17]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_18, __v_19]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_18, __v_19]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_608] = [__v_9, __v_10]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_9, __v_10]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52594,15 +53236,15 @@ fn aiur_fn_608( }) } -const INPUT_SIZE_609: usize = 4; -const IN_609: usize = 4; -const OUT_609: usize = 1; -fn aiur_fn_609( - inp: [G; IN_609], +const INPUT_SIZE_617: usize = 4; +const IN_617: usize = 4; +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_609], 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]; @@ -52612,16 +53254,16 @@ fn aiur_fn_609( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_3]; 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_618] = { let __args: [G; IN_618] = [__v_1, __v_3]; 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_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_617] = [__v_4]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_609] = [__v_4]; - record.function_queries[609].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); }, _ => { @@ -52633,15 +53275,15 @@ fn aiur_fn_609( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_609] = [__v_4]; - record.function_queries[609].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); }, 1u64 => { - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_1, __v_3]; 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_621] = { let __args: [G; IN_621] = [__v_1, __v_3]; 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_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_617] = [__v_4]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52656,15 +53298,15 @@ fn aiur_fn_609( }) } -const INPUT_SIZE_610: usize = 2; -const IN_610: usize = 2; -const OUT_610: usize = 1; -fn aiur_fn_610( - inp: [G; IN_610], +const INPUT_SIZE_618: usize = 2; +const IN_618: usize = 2; +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_610], 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]; @@ -52672,38 +53314,38 @@ fn aiur_fn_610( let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __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_728] = { let __args: [G; IN_728] = [__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 __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_728] = { let __args: [G; IN_728] = [__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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_5]; 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_599] = { let __args: [G; IN_599] = [__v_4, __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]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_2, __v_3]; 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_619] = { let __args: [G; IN_619] = [__v_2, __v_3]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_610] = [__v_7]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_618] = [__v_7]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_610] = [__v_6]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_618] = [__v_6]; + record.function_queries[618].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_619: usize = 2; +const IN_619: usize = 2; +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_611], 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]; @@ -52721,8 +53363,8 @@ fn aiur_fn_611( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_611] = [__v_12]; - record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_12]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -52739,14 +53381,14 @@ fn aiur_fn_611( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_11, __v_21]; 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_619] = { let __args: [G; IN_619] = [__v_11, __v_21]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__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[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_620] = { let __args: [G; IN_620] = [__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[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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_23]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_23]; 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_24: G = __r_arr[0]; - let __ret: [G; OUT_611] = [__v_24]; - record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_24]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52761,15 +53403,15 @@ fn aiur_fn_611( }) } -const INPUT_SIZE_612: usize = 16; -const IN_612: usize = 16; -const OUT_612: usize = 1; -fn aiur_fn_612( - inp: [G; IN_612], +const INPUT_SIZE_620: usize = 16; +const IN_620: usize = 16; +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_612], 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]; @@ -52787,51 +53429,51 @@ fn aiur_fn_612( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_7, __v_15]; 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_599] = { let __args: [G; IN_599] = [__v_7, __v_15]; 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_16: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_14]; 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_599] = { let __args: [G; IN_599] = [__v_6, __v_14]; 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 __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_5, __v_13]; 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_599] = { let __args: [G; IN_599] = [__v_5, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_4, __v_12]; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_11]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_11]; 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 __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_10]; 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_599] = { let __args: [G; IN_599] = [__v_2, __v_10]; 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_21: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_9]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_9]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_8]; 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_599] = { let __args: [G; IN_599] = [__v_0, __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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_23]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_23]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_21, __v_24]; 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_600] = { let __args: [G; IN_600] = [__v_21, __v_24]; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_20, __v_25]; 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_600] = { let __args: [G; IN_600] = [__v_20, __v_25]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_19, __v_26]; 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_600] = { let __args: [G; IN_600] = [__v_19, __v_26]; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_18, __v_27]; 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_600] = { let __args: [G; IN_600] = [__v_18, __v_27]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_17, __v_28]; 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_600] = { let __args: [G; IN_600] = [__v_17, __v_28]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_16, __v_29]; 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_600] = { let __args: [G; IN_600] = [__v_16, __v_29]; 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_30: G = __r_arr[0]; - let __ret: [G; OUT_612] = [__v_30]; - record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_620] = [__v_30]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_613: usize = 2; -const IN_613: usize = 2; -const OUT_613: usize = 1; -fn aiur_fn_613( - inp: [G; IN_613], +const INPUT_SIZE_621: usize = 2; +const IN_621: usize = 2; +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_613], 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]; @@ -52848,14 +53490,14 @@ fn aiur_fn_613( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_613] = [__v_8]; - record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_621] = [__v_8]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_613] = [__v_8]; - record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_621] = [__v_8]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52868,19 +53510,19 @@ fn aiur_fn_613( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_613] = [__v_8]; - record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_621] = [__v_8]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_6]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !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_621] = { let __args: [G; IN_621] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_9]; 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_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_613] = [__v_10]; - record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_621] = [__v_10]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52895,15 +53537,15 @@ fn aiur_fn_613( }) } -const INPUT_SIZE_614: usize = 6; -const IN_614: usize = 6; -const OUT_614: usize = 1; -fn aiur_fn_614( - inp: [G; IN_614], +const INPUT_SIZE_622: usize = 6; +const IN_622: usize = 6; +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_614], 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]; @@ -52915,18 +53557,18 @@ fn aiur_fn_614( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_3]; 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_599] = { let __args: [G; IN_599] = [__v_0, __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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __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_599] = { let __args: [G; IN_599] = [__v_1, __v_4]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_5]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_7, __v_8]; 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_600] = { let __args: [G; IN_600] = [__v_7, __v_8]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_9]; 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_600] = { let __args: [G; IN_600] = [__v_6, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_10]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_622] = [__v_10]; + record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52935,15 +53577,15 @@ fn aiur_fn_614( }) } -const INPUT_SIZE_615: usize = 2; -const IN_615: usize = 2; -const OUT_615: usize = 1; -fn aiur_fn_615( - inp: [G; IN_615], +const INPUT_SIZE_623: usize = 2; +const IN_623: usize = 2; +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_615], 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]; @@ -52964,14 +53606,14 @@ fn aiur_fn_615( match __v_7.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_615] = [__v_12]; - record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_12]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_615] = [__v_12]; - record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_12]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52986,19 +53628,19 @@ fn aiur_fn_615( match __v_7.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(2); - let __ret: [G; OUT_615] = [__v_12]; - record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_12]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; 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_622] = { let __args: [G; IN_622] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; 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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_6, __v_11]; 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 __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_6, __v_11]; 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_13: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_12, __v_13]; 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_600] = { let __args: [G; IN_600] = [__v_12, __v_13]; 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_14: G = __r_arr[0]; - let __ret: [G; OUT_615] = [__v_14]; - record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_14]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53013,15 +53655,15 @@ fn aiur_fn_615( }) } -const INPUT_SIZE_616: usize = 7; -const IN_616: usize = 7; -const OUT_616: usize = 2; -fn aiur_fn_616( - inp: [G; IN_616], +const INPUT_SIZE_624: usize = 7; +const IN_624: usize = 7; +const OUT_624: usize = 2; +fn aiur_fn_624( + inp: [G; IN_624], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_616], 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]; @@ -53034,27 +53676,27 @@ fn aiur_fn_616( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_3]; 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_599] = { let __args: [G; IN_599] = [__v_0, __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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7]; 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_607] = { let __args: [G; IN_607] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __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_599] = { let __args: [G; IN_599] = [__v_1, __v_4]; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_10]; 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_607] = { let __args: [G; IN_607] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_5, __v_6]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_5, __v_6]; 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 __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_12, __v_13, __v_14]; 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_606] = { let __args: [G; IN_606] = [__v_11, __v_12, __v_13, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_8, __v_9, __v_15, __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_606] = { let __args: [G; IN_606] = [__v_8, __v_9, __v_15, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_17, __v_18]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_624] = [__v_17, __v_18]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53063,15 +53705,15 @@ fn aiur_fn_616( }) } -const INPUT_SIZE_617: usize = 3; -const IN_617: usize = 3; -const OUT_617: usize = 2; -fn aiur_fn_617( - inp: [G; IN_617], +const INPUT_SIZE_625: usize = 3; +const IN_625: usize = 3; +const OUT_625: usize = 2; +fn aiur_fn_625( + inp: [G; IN_625], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_617], 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]; @@ -53092,19 +53734,19 @@ fn aiur_fn_617( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = []; 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_603] = { let __args: [G; IN_603] = []; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_617] = [__v_13, __v_14]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_625] = [__v_13, __v_14]; + record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; 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_601] = { let __args: [G; IN_601] = []; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_617] = [__v_13, __v_14]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_625] = [__v_13, __v_14]; + record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53118,25 +53760,25 @@ fn aiur_fn_617( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; 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_605] = { let __args: [G; IN_605] = []; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_617] = [__v_13, __v_14]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_625] = [__v_13, __v_14]; + record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; 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_624] = { let __args: [G; IN_624] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_7, __v_12, __v_2]; 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_625] = { let __args: [G; IN_625] = [__v_7, __v_12, __v_2]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_13, __v_14, __v_15, __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_606] = { let __args: [G; IN_606] = [__v_13, __v_14, __v_15, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_617] = [__v_17, __v_18]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_625] = [__v_17, __v_18]; + record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53151,15 +53793,15 @@ fn aiur_fn_617( }) } -const INPUT_SIZE_618: usize = 11; -const IN_618: usize = 11; -const OUT_618: usize = 1; -fn aiur_fn_618( - inp: [G; IN_618], +const INPUT_SIZE_626: usize = 11; +const IN_626: usize = 11; +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_618], 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]; @@ -53175,50 +53817,50 @@ fn aiur_fn_618( match __v_0.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_618] = [__v_11]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_11]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_618] = [__v_11]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_11]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_618] = [__v_11]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_11]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_618] = [__v_11]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_11]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_11: G = G::from_u64(2); - let __ret: [G; OUT_618] = [__v_11]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_11]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_11: G = G::from_u64(3); - let __ret: [G; OUT_618] = [__v_11]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_11]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(4); - let __ret: [G; OUT_618] = [__v_11]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_11]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_11: G = G::from_u64(5); - let __ret: [G; OUT_618] = [__v_11]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_11]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53228,15 +53870,15 @@ fn aiur_fn_618( }) } -const INPUT_SIZE_619: usize = 22; -const IN_619: usize = 22; -const OUT_619: usize = 1; -fn aiur_fn_619( - inp: [G; IN_619], +const INPUT_SIZE_627: usize = 22; +const IN_627: usize = 22; +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_619], 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]; @@ -53260,38 +53902,38 @@ fn aiur_fn_619( let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; - 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]; 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_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]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_11, __v_12, __v_13, __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[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_626] = { let __args: [G; IN_626] = [__v_11, __v_12, __v_13, __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[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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_22, __v_23]; 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_599] = { let __args: [G; IN_599] = [__v_22, __v_23]; 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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __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[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_628] = { let __args: [G; IN_628] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __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[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_25: G = __r_arr[0]; - let __ret: [G; OUT_619] = [__v_25]; - record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_627] = [__v_25]; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_619] = [__v_24]; - record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_627] = [__v_24]; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_620: usize = 22; -const IN_620: usize = 22; -const OUT_620: usize = 1; -fn aiur_fn_620( - inp: [G; IN_620], +const INPUT_SIZE_628: usize = 22; +const IN_628: usize = 22; +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_620], 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]; @@ -53319,18 +53961,18 @@ fn aiur_fn_620( 1u64 => { match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_13]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_3, __v_14]; 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_613] = { let __args: [G; IN_613] = [__v_3, __v_14]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_24]; 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_600] = { let __args: [G; IN_600] = [__v_23, __v_24]; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_25]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_25]; 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_26: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_26]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_26]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53341,18 +53983,18 @@ fn aiur_fn_620( 2u64 => { match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_13]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_3, __v_14]; 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_613] = { let __args: [G; IN_613] = [__v_3, __v_14]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_24]; 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_600] = { let __args: [G; IN_600] = [__v_23, __v_24]; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_25]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_25]; 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_26: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_26]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_26]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53363,22 +54005,22 @@ fn aiur_fn_620( 3u64 => { match __v_11.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_13]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_3, __v_14]; 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_613] = { let __args: [G; IN_613] = [__v_3, __v_14]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_15]; 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_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_24, __v_25]; 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_600] = { let __args: [G; IN_600] = [__v_24, __v_25]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_26]; 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_600] = { let __args: [G; IN_600] = [__v_23, __v_26]; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_27]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_27]; 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_28: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_28]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_28]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53389,14 +54031,14 @@ fn aiur_fn_620( 4u64 => { match __v_11.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_13]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_23]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_23]; 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_24: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_24]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_24]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53407,18 +54049,18 @@ fn aiur_fn_620( 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_13]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_14]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_24]; 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_600] = { let __args: [G; IN_600] = [__v_23, __v_24]; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_25]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_25]; 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_26: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_26]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_26]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53429,38 +54071,38 @@ fn aiur_fn_620( 5u64 => { match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_17]; 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_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_8, __v_19]; 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_599] = { let __args: [G; IN_599] = [__v_8, __v_19]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_14]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_15]; 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_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_27, __v_28]; 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_599] = { let __args: [G; IN_599] = [__v_27, __v_28]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_13]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_30: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_29, __v_30]; 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_600] = { let __args: [G; IN_600] = [__v_29, __v_30]; 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_31: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_26, __v_31]; 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_600] = { let __args: [G; IN_600] = [__v_26, __v_31]; 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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_25, __v_32]; 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_600] = { let __args: [G; IN_600] = [__v_25, __v_32]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_24, __v_33]; 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_600] = { let __args: [G; IN_600] = [__v_24, __v_33]; 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_34: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_34]; 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_600] = { let __args: [G; IN_600] = [__v_23, __v_34]; 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_35: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_35]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_35]; 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_36: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_36]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_36]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53471,26 +54113,26 @@ fn aiur_fn_620( 6u64 => { match __v_11.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_15]; 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_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_5, __v_16]; 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_599] = { let __args: [G; IN_599] = [__v_5, __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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_17]; 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_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_13]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_25, __v_26]; 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_600] = { let __args: [G; IN_600] = [__v_25, __v_26]; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_24, __v_27]; 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_600] = { let __args: [G; IN_600] = [__v_24, __v_27]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_28]; 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_600] = { let __args: [G; IN_600] = [__v_23, __v_28]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_29]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_29]; 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_30: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_30]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_30]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53501,38 +54143,38 @@ fn aiur_fn_620( 7u64 => { match __v_11.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_14]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_15]; 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_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_5, __v_16]; 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_599] = { let __args: [G; IN_599] = [__v_5, __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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_17]; 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_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_8, __v_19]; 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_599] = { let __args: [G; IN_599] = [__v_8, __v_19]; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_13]; 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_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_7, __v_18]; 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 __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_7, __v_18]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_28, __v_29]; 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_600] = { let __args: [G; IN_600] = [__v_28, __v_29]; 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_30: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_27, __v_30]; 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_600] = { let __args: [G; IN_600] = [__v_27, __v_30]; 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_31: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_26, __v_31]; 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_600] = { let __args: [G; IN_600] = [__v_26, __v_31]; 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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_25, __v_32]; 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_600] = { let __args: [G; IN_600] = [__v_25, __v_32]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_24, __v_33]; 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_600] = { let __args: [G; IN_600] = [__v_24, __v_33]; 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_34: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_34]; 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_600] = { let __args: [G; IN_600] = [__v_23, __v_34]; 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_35: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_35]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_35]; 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_36: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_36]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_36]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53547,15 +54189,15 @@ fn aiur_fn_620( }) } -const INPUT_SIZE_621: usize = 23; -const IN_621: usize = 23; -const OUT_621: usize = 2; -fn aiur_fn_621( - inp: [G; IN_621], +const INPUT_SIZE_629: usize = 23; +const IN_629: usize = 23; +const OUT_629: usize = 2; +fn aiur_fn_629( + inp: [G; IN_629], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_621], 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]; @@ -53580,42 +54222,42 @@ fn aiur_fn_621( let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; - 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]; 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_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]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_11, __v_12, __v_13, __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[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_626] = { let __args: [G; IN_626] = [__v_11, __v_12, __v_13, __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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_23, __v_24]; 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_599] = { let __args: [G; IN_599] = [__v_23, __v_24]; 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_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; 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_630] = { let __args: [G; IN_630] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __ret: [G; OUT_621] = [__v_26, __v_27]; - record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_26, __v_27]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_25]; 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_607] = { let __args: [G; IN_607] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __ret: [G; OUT_621] = [__v_26, __v_27]; - record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_26, __v_27]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_622: usize = 23; -const IN_622: usize = 23; -const OUT_622: usize = 2; -fn aiur_fn_622( - inp: [G; IN_622], +const INPUT_SIZE_630: usize = 23; +const IN_630: usize = 23; +const OUT_630: usize = 2; +fn aiur_fn_630( + inp: [G; IN_630], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_622], 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]; @@ -53644,25 +54286,25 @@ fn aiur_fn_622( 1u64 => { match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_23]; 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_607] = { let __args: [G; IN_607] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_13, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_3, __v_14, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_3, __v_14, __v_22]; 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 __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_26, __v_27, __v_28, __v_29]; 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_606] = { let __args: [G; IN_606] = [__v_26, __v_27, __v_28, __v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_24, __v_25, __v_30, __v_31]; 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_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_30, __v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __ret: [G; OUT_622] = [__v_32, __v_33]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_32, __v_33]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53673,25 +54315,25 @@ fn aiur_fn_622( 2u64 => { match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_23]; 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_607] = { let __args: [G; IN_607] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_13, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_3, __v_14, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_3, __v_14, __v_22]; 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 __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_26, __v_27, __v_28, __v_29]; 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_606] = { let __args: [G; IN_606] = [__v_26, __v_27, __v_28, __v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_24, __v_25, __v_30, __v_31]; 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_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_30, __v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __ret: [G; OUT_622] = [__v_32, __v_33]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_32, __v_33]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53702,33 +54344,33 @@ fn aiur_fn_622( 3u64 => { match __v_11.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_23]; 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_607] = { let __args: [G; IN_607] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_13, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_3, __v_14, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_3, __v_14, __v_22]; 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 __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_15]; 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_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_30: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30]; 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_607] = { let __args: [G; IN_607] = [__v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_28, __v_29, __v_31, __v_32]; 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_606] = { let __args: [G; IN_606] = [__v_28, __v_29, __v_31, __v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_26, __v_27, __v_33, __v_34]; 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_606] = { let __args: [G; IN_606] = [__v_26, __v_27, __v_33, __v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_24, __v_25, __v_35, __v_36]; 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_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_35, __v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __ret: [G; OUT_622] = [__v_37, __v_38]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_37, __v_38]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53739,19 +54381,19 @@ fn aiur_fn_622( 4u64 => { match __v_11.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_23]; 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_607] = { let __args: [G; IN_607] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_13, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_24, __v_25, __v_26, __v_27]; 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_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_26, __v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_622] = [__v_28, __v_29]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_28, __v_29]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53762,27 +54404,27 @@ fn aiur_fn_622( 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_23]; 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_607] = { let __args: [G; IN_607] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_13, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_14]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_28]; 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_607] = { let __args: [G; IN_607] = [__v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_26, __v_27, __v_29, __v_30]; 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_606] = { let __args: [G; IN_606] = [__v_26, __v_27, __v_29, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_24, __v_25, __v_31, __v_32]; 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_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_31, __v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __ret: [G; OUT_622] = [__v_33, __v_34]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_33, __v_34]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53793,63 +54435,63 @@ fn aiur_fn_622( 5u64 => { match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_17]; 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_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_23]; 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_607] = { let __args: [G; IN_607] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_8, __v_19]; 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_599] = { let __args: [G; IN_599] = [__v_8, __v_19]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26]; 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_607] = { let __args: [G; IN_607] = [__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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_29]; 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_607] = { let __args: [G; IN_607] = [__v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_14]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_32]; 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_607] = { let __args: [G; IN_607] = [__v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_15]; 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_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_35: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_35]; 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_607] = { let __args: [G; IN_607] = [__v_35]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_38, __v_39]; 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_599] = { let __args: [G; IN_599] = [__v_38, __v_39]; 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_40: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_40]; 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_607] = { let __args: [G; IN_607] = [__v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_13, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_41, __v_42, __v_43, __v_44]; 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_606] = { let __args: [G; IN_606] = [__v_41, __v_42, __v_43, __v_44]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_36, __v_37, __v_45, __v_46]; 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_606] = { let __args: [G; IN_606] = [__v_36, __v_37, __v_45, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_33, __v_34, __v_47, __v_48]; 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_606] = { let __args: [G; IN_606] = [__v_33, __v_34, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_30, __v_31, __v_49, __v_50]; 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_606] = { let __args: [G; IN_606] = [__v_30, __v_31, __v_49, __v_50]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_27, __v_28, __v_51, __v_52]; 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_606] = { let __args: [G; IN_606] = [__v_27, __v_28, __v_51, __v_52]; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_24, __v_25, __v_53, __v_54]; 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_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_53, __v_54]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __ret: [G; OUT_622] = [__v_55, __v_56]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_55, __v_56]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53860,43 +54502,43 @@ fn aiur_fn_622( 6u64 => { match __v_11.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_23]; 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_607] = { let __args: [G; IN_607] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_15]; 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_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26]; 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_607] = { let __args: [G; IN_607] = [__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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_5, __v_16]; 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_599] = { let __args: [G; IN_599] = [__v_5, __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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_29]; 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_607] = { let __args: [G; IN_607] = [__v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_17]; 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_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_32]; 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_607] = { let __args: [G; IN_607] = [__v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_13, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_33, __v_34, __v_35, __v_36]; 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_606] = { let __args: [G; IN_606] = [__v_33, __v_34, __v_35, __v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_30, __v_31, __v_37, __v_38]; 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_606] = { let __args: [G; IN_606] = [__v_30, __v_31, __v_37, __v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_27, __v_28, __v_39, __v_40]; 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_606] = { let __args: [G; IN_606] = [__v_27, __v_28, __v_39, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_24, __v_25, __v_41, __v_42]; 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_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_41, __v_42]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __ret: [G; OUT_622] = [__v_43, __v_44]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_43, __v_44]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53907,65 +54549,65 @@ fn aiur_fn_622( 7u64 => { match __v_11.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_1, __v_12]; 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_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_23]; 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_607] = { let __args: [G; IN_607] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_14]; 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_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26]; 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_607] = { let __args: [G; IN_607] = [__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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_15]; 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_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_29]; 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_607] = { let __args: [G; IN_607] = [__v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_5, __v_16]; 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_599] = { let __args: [G; IN_599] = [__v_5, __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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_32]; 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_607] = { let __args: [G; IN_607] = [__v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_17]; 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_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_35: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_35]; 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_607] = { let __args: [G; IN_607] = [__v_35]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_8, __v_19]; 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_599] = { let __args: [G; IN_599] = [__v_8, __v_19]; 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_38: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_38]; 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_607] = { let __args: [G; IN_607] = [__v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_13, __v_22]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_7, __v_18, __v_22]; 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_625] = { let __args: [G; IN_625] = [__v_7, __v_18, __v_22]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_41, __v_42, __v_43, __v_44]; 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_606] = { let __args: [G; IN_606] = [__v_41, __v_42, __v_43, __v_44]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_39, __v_40, __v_45, __v_46]; 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_606] = { let __args: [G; IN_606] = [__v_39, __v_40, __v_45, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_36, __v_37, __v_47, __v_48]; 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_606] = { let __args: [G; IN_606] = [__v_36, __v_37, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_33, __v_34, __v_49, __v_50]; 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_606] = { let __args: [G; IN_606] = [__v_33, __v_34, __v_49, __v_50]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_30, __v_31, __v_51, __v_52]; 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_606] = { let __args: [G; IN_606] = [__v_30, __v_31, __v_51, __v_52]; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_27, __v_28, __v_53, __v_54]; 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_606] = { let __args: [G; IN_606] = [__v_27, __v_28, __v_53, __v_54]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_24, __v_25, __v_55, __v_56]; 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_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_55, __v_56]; 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_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __ret: [G; OUT_622] = [__v_57, __v_58]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_57, __v_58]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53980,15 +54622,15 @@ fn aiur_fn_622( }) } -const INPUT_SIZE_623: usize = 4; -const IN_623: usize = 4; -const OUT_623: usize = 1; -fn aiur_fn_623( - inp: [G; IN_623], +const INPUT_SIZE_631: usize = 4; +const IN_631: usize = 4; +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_623], 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]; @@ -54003,8 +54645,8 @@ fn aiur_fn_623( 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_623] = [__v_9]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_9]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -54020,11 +54662,11 @@ fn aiur_fn_623( let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; 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_633] = { let __args: [G; IN_633] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; 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_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = (__v_3 + __v_19); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_6, __v_2, __v_20]; 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_631] = { let __args: [G; IN_631] = [__v_0, __v_6, __v_2, __v_20]; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_18, __v_0]; 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_22: G = __r_arr[0]; @@ -54032,13 +54674,13 @@ fn aiur_fn_623( 1u64 => { let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 3] = [__v_23, __v_3, __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_623] = [__v_24]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_24]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_623] = [__v_21]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_21]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54053,15 +54695,15 @@ fn aiur_fn_623( }) } -const INPUT_SIZE_624: usize = 1; -const IN_624: usize = 1; -const OUT_624: usize = 0; -fn aiur_fn_624( - inp: [G; IN_624], +const INPUT_SIZE_632: usize = 1; +const IN_632: usize = 1; +const OUT_632: usize = 0; +fn aiur_fn_632( + inp: [G; IN_632], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_624], ExecError> { +) -> Result<[G; OUT_632], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -54101,22 +54743,22 @@ fn aiur_fn_624( 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 __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_0, __v_33, __v_36, __v_37, __v_0]; 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 __ret: [G; OUT_624] = []; - record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_33, __v_36, __v_37, __v_0]; 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 __ret: [G; OUT_632] = []; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_625: usize = 12; -const IN_625: usize = 12; -const OUT_625: usize = 1; -fn aiur_fn_625( - inp: [G; IN_625], +const INPUT_SIZE_633: usize = 12; +const IN_633: usize = 12; +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_625], 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]; @@ -54132,12 +54774,12 @@ fn aiur_fn_625( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_625] = [__v_10]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_10]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __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_726] = { let __args: [G; IN_726] = [__v_11, __v_3]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -54153,8 +54795,8 @@ fn aiur_fn_625( let __v_23: G = __loaded[10]; match __v_13.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_625] = [__v_23]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_23]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54191,15 +54833,15 @@ fn aiur_fn_625( let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 32] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_56]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_56]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 7u64 => { - let __ret: [G; OUT_625] = [__v_10]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_10]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54236,23 +54878,23 @@ fn aiur_fn_625( 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 __ret: [G; OUT_625] = [__v_44]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_44]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_626: usize = 5; -const IN_626: usize = 5; -const OUT_626: usize = 0; -fn aiur_fn_626( - inp: [G; IN_626], +const INPUT_SIZE_634: usize = 5; +const IN_634: usize = 5; +const OUT_634: usize = 0; +fn aiur_fn_634( + inp: [G; IN_634], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_626], 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]; @@ -54265,9 +54907,9 @@ fn aiur_fn_626( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_1, __v_2, __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 __ret: [G; OUT_626] = []; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_1, __v_2, __v_4]; 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 __ret: [G; OUT_634] = []; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -54283,30 +54925,30 @@ fn aiur_fn_626( let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_4]; 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_633] = { let __args: [G; IN_633] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_4]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_19, __v_1]; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_2, __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_718] = { let __args: [G; IN_718] = [__v_2, __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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_3 + __v_22); - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_7, __v_19, __v_21, __v_23, __v_4]; 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 __ret: [G; OUT_626] = []; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_7, __v_19, __v_21, __v_23, __v_4]; 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 __ret: [G; OUT_634] = []; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_1, __v_2, __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_19, __v_3]; 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_636] = { let __args: [G; IN_636] = [__v_1, __v_2, __v_4]; 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_19, __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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_3 + __v_22); - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_7, __v_19, __v_21, __v_23, __v_4]; 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 __ret: [G; OUT_626] = []; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_7, __v_19, __v_21, __v_23, __v_4]; 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 __ret: [G; OUT_634] = []; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54321,15 +54963,15 @@ fn aiur_fn_626( }) } -const INPUT_SIZE_627: usize = 2; -const IN_627: usize = 2; -const OUT_627: usize = 1; -fn aiur_fn_627( - inp: [G; IN_627], +const INPUT_SIZE_635: usize = 2; +const IN_635: usize = 2; +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_627], 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]; @@ -54373,8 +55015,8 @@ fn aiur_fn_627( 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_627] = [__v_38]; - record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_635] = [__v_38]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -54383,8 +55025,8 @@ fn aiur_fn_627( let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = { let __values: [G; 3] = [__v_36, __v_1, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_627] = [__v_40]; - record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_635] = [__v_40]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54394,15 +55036,15 @@ fn aiur_fn_627( }) } -const INPUT_SIZE_628: usize = 3; -const IN_628: usize = 3; -const OUT_628: usize = 0; -fn aiur_fn_628( - inp: [G; IN_628], +const INPUT_SIZE_636: usize = 3; +const IN_636: usize = 3; +const OUT_636: usize = 0; +fn aiur_fn_636( + inp: [G; IN_636], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_628], 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]; @@ -54444,8 +55086,8 @@ fn aiur_fn_628( let __v_36: G = __r_arr[0]; match __v_36.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_628] = []; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_636] = []; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -54453,19 +55095,19 @@ fn aiur_fn_628( let __v_37: G = __r_arr[0]; match __v_37.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_628] = []; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_636] = []; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_628] = []; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_636] = []; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_2]; 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 __ret: [G; OUT_628] = []; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__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 __ret: [G; OUT_636] = []; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -54477,39 +55119,39 @@ fn aiur_fn_628( }) } -const INPUT_SIZE_629: usize = 2; -const IN_629: usize = 2; -const OUT_629: usize = 0; -fn aiur_fn_629( - inp: [G; IN_629], +const INPUT_SIZE_637: usize = 2; +const IN_637: usize = 2; +const OUT_637: usize = 0; +fn aiur_fn_637( + inp: [G; IN_637], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_629], 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]; - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_1]; 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_638] = { let __args: [G; IN_638] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !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_2: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_629] = []; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_637] = []; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_629] = []; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_637] = []; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_2, __v_1]; 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_641] = { let __args: [G; IN_641] = [__v_2, __v_1]; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4]; 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_639] = { let __args: [G; IN_639] = [__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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4]; 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_640] = { let __args: [G; IN_640] = [__v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_6, __v_2]; 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_7: G = __r_arr[0]; @@ -54521,23 +55163,23 @@ fn aiur_fn_629( if (__v_7 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); } - let __ret: [G; OUT_629] = []; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_637] = []; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -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_638: usize = 2; +const IN_638: usize = 2; +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_630], 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]; @@ -54550,12 +55192,12 @@ fn aiur_fn_630( 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_630] = [__v_7]; - record.function_queries[630].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)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_5: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -54569,21 +55211,21 @@ fn aiur_fn_630( let __v_14: G = __loaded[8]; let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_4, __v_1]; 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_638] = { let __args: [G; IN_638] = [__v_4, __v_1]; 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_17: G = __r_arr[0]; - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; 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_626] = { let __args: [G; IN_626] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_3, __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_630] = [__v_20]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_638] = [__v_20]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_630] = [__v_17]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_638] = [__v_17]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -54595,15 +55237,15 @@ fn aiur_fn_630( }) } -const INPUT_SIZE_631: usize = 1; -const IN_631: usize = 1; -const OUT_631: usize = 1; -fn aiur_fn_631( - inp: [G; IN_631], +const INPUT_SIZE_639: usize = 1; +const IN_639: usize = 1; +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_631], ExecError> { +) -> Result<[G; OUT_639], 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 }; @@ -54613,8 +55255,8 @@ fn aiur_fn_631( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_631] = [__v_4]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_639] = [__v_4]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -54622,16 +55264,16 @@ fn aiur_fn_631( let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3]; 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_639] = { let __args: [G; IN_639] = [__v_3]; 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_5: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_5]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_639] = [__v_5]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_5]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_639] = [__v_5]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -54643,15 +55285,15 @@ fn aiur_fn_631( }) } -const INPUT_SIZE_632: usize = 1; -const IN_632: usize = 1; -const OUT_632: usize = 1; -fn aiur_fn_632( - inp: [G; IN_632], +const INPUT_SIZE_640: usize = 1; +const IN_640: usize = 1; +const OUT_640: usize = 1; +fn aiur_fn_640( + inp: [G; IN_640], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_632], ExecError> { +) -> Result<[G; OUT_640], 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 }; @@ -54663,17 +55305,17 @@ fn aiur_fn_632( 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_632] = [__v_6]; - record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_640] = [__v_6]; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3]; 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_640] = { let __args: [G; IN_640] = [__v_3]; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_4]; 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_721] = { let __args: [G; IN_721] = [__v_2, __v_4]; 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 __ret: [G; OUT_632] = [__v_5]; - record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_640] = [__v_5]; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54683,15 +55325,15 @@ fn aiur_fn_632( }) } -const INPUT_SIZE_633: usize = 2; -const IN_633: usize = 2; -const OUT_633: usize = 1; -fn aiur_fn_633( - inp: [G; IN_633], +const INPUT_SIZE_641: usize = 2; +const IN_641: usize = 2; +const OUT_641: usize = 1; +fn aiur_fn_641( + inp: [G; IN_641], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_633], 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]; @@ -54701,53 +55343,53 @@ fn aiur_fn_633( 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 = { let __values: [G; 3] = [__v_2, __v_0, __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(32); - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_6, __v_1, __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_642] = { let __args: [G; IN_642] = [__v_6, __v_1, __v_7]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_633] = [__v_8]; - record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_641] = [__v_8]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_634: usize = 3; -const IN_634: usize = 3; -const OUT_634: usize = 1; -fn aiur_fn_634( - inp: [G; IN_634], +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_634], ExecError> { +) -> Result<[G; OUT_642], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_634] = [__v_0]; - record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_0]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0]; 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_640] = { let __args: [G; IN_640] = [__v_0]; 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 __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_3, __v_1]; 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_643] = { let __args: [G; IN_643] = [__v_0, __v_3, __v_1]; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_0, __v_4]; 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_649] = { let __args: [G; IN_649] = [__v_0, __v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_634] = [__v_0]; - record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_0]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_1, __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_642] = { let __args: [G; IN_642] = [__v_4, __v_1, __v_7]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_634] = [__v_8]; - record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_8]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -54756,15 +55398,15 @@ fn aiur_fn_634( }) } -const INPUT_SIZE_635: usize = 3; -const IN_635: usize = 3; -const OUT_635: usize = 1; -fn aiur_fn_635( - inp: [G; IN_635], +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_635], 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]; @@ -54778,19 +55420,19 @@ fn aiur_fn_635( 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_635] = [__v_8]; - record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_643] = [__v_8]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_4, __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_644] = { let __args: [G; IN_644] = [__v_4, __v_1, __v_2]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_5, __v_1, __v_2]; 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_643] = { let __args: [G; IN_643] = [__v_5, __v_1, __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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_6, __v_7]; 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_721] = { let __args: [G; IN_721] = [__v_6, __v_7]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_635] = [__v_8]; - record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_643] = [__v_8]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54800,15 +55442,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_644: usize = 3; +const IN_644: usize = 3; +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_636], 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]; @@ -54820,8 +55462,8 @@ fn aiur_fn_636( 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_636] = [__v_6]; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_644] = [__v_6]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -54830,32 +55472,32 @@ fn aiur_fn_636( 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_636] = [__v_8]; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_644] = [__v_8]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_0, __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_645] = { let __args: [G; IN_645] = [__v_0, __v_1, __v_2]; 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 __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_4, __v_1, __v_2]; 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_647] = { let __args: [G; IN_647] = [__v_4, __v_1, __v_2]; 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_5: G = __r_arr[0]; - let __ret: [G; OUT_636] = [__v_5]; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_644] = [__v_5]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -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_645: usize = 3; +const IN_645: usize = 3; +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_637], 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]; @@ -54869,17 +55511,17 @@ fn aiur_fn_637( 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 __ret: [G; OUT_645] = [__v_8]; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - 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_645] = { let __args: [G; IN_645] = [__v_5, __v_1, __v_2]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_4, __v_6, __v_1, __v_2]; 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_646] = { let __args: [G; IN_646] = [__v_4, __v_6, __v_1, __v_2]; 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 __v_7: G = __r_arr[0]; - let __ret: [G; OUT_637] = [__v_7]; - record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_645] = [__v_7]; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54889,15 +55531,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_646: usize = 4; +const IN_646: usize = 4; +const OUT_646: usize = 1; +fn aiur_fn_646( + inp: [G; IN_646], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_638], 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]; @@ -54914,12 +55556,12 @@ fn aiur_fn_638( 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_638] = [__v_11]; - record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_646] = [__v_11]; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __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_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -54933,7 +55575,7 @@ fn aiur_fn_638( let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_5]; 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_19: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -54947,24 +55589,24 @@ fn aiur_fn_638( let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_8, __v_9, __v_10, __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_28, __v_29, __v_30, __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_629] = { let __args: [G; IN_629] = [__v_8, __v_9, __v_10, __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_28, __v_29, __v_30, __v_2]; 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_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_638] = [__v_34]; - record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_646] = [__v_34]; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_6, __v_2, __v_3]; 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_646] = { let __args: [G; IN_646] = [__v_0, __v_6, __v_2, __v_3]; 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 __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_638] = [__v_35]; - record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_646] = [__v_35]; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -54976,15 +55618,15 @@ fn aiur_fn_638( }) } -const INPUT_SIZE_639: usize = 3; -const IN_639: usize = 3; -const OUT_639: usize = 1; -fn aiur_fn_639( - inp: [G; IN_639], +const INPUT_SIZE_647: usize = 3; +const IN_647: usize = 3; +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_639], 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]; @@ -54998,8 +55640,8 @@ fn aiur_fn_639( 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_639] = [__v_8]; - record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_647] = [__v_8]; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -55008,10 +55650,10 @@ fn aiur_fn_639( 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_640] = { let __args: [G; IN_640] = [__v_5, __v_1, __v_2, __v_4, __v_10]; 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_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_4, __v_10]; 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_11: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_11]; - record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_647] = [__v_11]; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55021,15 +55663,15 @@ fn aiur_fn_639( }) } -const INPUT_SIZE_640: usize = 5; -const IN_640: usize = 5; -const OUT_640: usize = 1; -fn aiur_fn_640( - inp: [G; IN_640], +const INPUT_SIZE_648: usize = 5; +const IN_648: usize = 5; +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_640], 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]; @@ -55047,12 +55689,12 @@ fn aiur_fn_640( 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_640] = [__v_12]; - record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_648] = [__v_12]; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __v_3]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -55066,7 +55708,7 @@ fn aiur_fn_640( let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_726] = { let __args: [G; IN_726] = [__v_2, __v_6]; 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_20: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -55080,17 +55722,17 @@ fn aiur_fn_640( let __v_29: G = __loaded[8]; let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_9, __v_10, __v_11, __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_29, __v_30, __v_31, __v_1]; 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_629] = { let __args: [G; IN_629] = [__v_9, __v_10, __v_11, __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_29, __v_30, __v_31, __v_1]; 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_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_718] = { let __args: [G; IN_718] = [__v_4, __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_34: G = __r_arr[0]; - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_7, __v_1, __v_2, __v_6, __v_34]; 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_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2, __v_6, __v_34]; 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_35: G = __r_arr[0]; - let __ret: [G; OUT_640] = [__v_35]; - record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_648] = [__v_35]; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55100,11 +55742,11 @@ fn aiur_fn_640( 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_640] = { let __args: [G; IN_640] = [__v_7, __v_1, __v_2, __v_6, __v_39]; 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_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2, __v_6, __v_39]; 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_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_640] = [__v_41]; - record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_648] = [__v_41]; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55116,15 +55758,15 @@ fn aiur_fn_640( }) } -const INPUT_SIZE_641: usize = 2; -const IN_641: usize = 2; -const OUT_641: usize = 1; -fn aiur_fn_641( - inp: [G; IN_641], +const INPUT_SIZE_649: usize = 2; +const IN_649: usize = 2; +const OUT_649: usize = 1; +fn aiur_fn_649( + inp: [G; IN_649], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_641], 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]; @@ -55141,14 +55783,14 @@ fn aiur_fn_641( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_641] = [__v_8]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_8]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_641] = [__v_8]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_8]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55161,8 +55803,8 @@ fn aiur_fn_641( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_641] = [__v_8]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_8]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -55171,15 +55813,15 @@ fn aiur_fn_641( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_641] = [__v_9]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_9]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_7]; 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_649] = { let __args: [G; IN_649] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; - let __ret: [G; OUT_641] = [__v_9]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_9]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55196,15 +55838,15 @@ fn aiur_fn_641( }) } -const INPUT_SIZE_642: usize = 11; -const IN_642: usize = 11; -const OUT_642: usize = 1; -fn aiur_fn_642( - inp: [G; IN_642], +const INPUT_SIZE_650: usize = 11; +const IN_650: usize = 11; +const OUT_650: usize = 1; +fn aiur_fn_650( + inp: [G; IN_650], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_642], 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]; @@ -55219,56 +55861,56 @@ fn aiur_fn_642( let __v_10: G = inp[10]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_642] = [__v_3]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_3]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_642] = [__v_11]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_11]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_642] = [__v_11]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_11]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 2u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_642] = [__v_11]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_11]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_642] = [__v_4]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_4]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_642] = [__v_11]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_11]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_642] = [__v_8]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_8]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_642] = [__v_7]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_7]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_642] = [__v_9]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_9]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55278,15 +55920,15 @@ fn aiur_fn_642( }) } -const INPUT_SIZE_643: usize = 2; -const IN_643: usize = 2; -const OUT_643: usize = 1; -fn aiur_fn_643( - inp: [G; IN_643], +const INPUT_SIZE_651: usize = 2; +const IN_651: usize = 2; +const OUT_651: usize = 1; +fn aiur_fn_651( + inp: [G; IN_651], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_643], 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]; @@ -55298,18 +55940,18 @@ fn aiur_fn_643( match __v_2.as_canonical_u64() { 0u64 => { 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_651] = [__v_6]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 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_651] = [__v_6]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_6: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -55324,67 +55966,67 @@ fn aiur_fn_643( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__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[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_650] = { let __args: [G; IN_650] = [__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[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_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); - let __ret: [G; OUT_643] = [__v_20]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_651] = [__v_20]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_3, __v_1]; 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_651] = { let __args: [G; IN_651] = [__v_3, __v_1]; 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 __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_4, __v_1]; 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_651] = { let __args: [G; IN_651] = [__v_4, __v_1]; 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 __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); - let __ret: [G; OUT_643] = [__v_8]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_651] = [__v_8]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_3, __v_1]; 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_651] = { let __args: [G; IN_651] = [__v_3, __v_1]; 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 __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_4, __v_1]; 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_651] = { let __args: [G; IN_651] = [__v_4, __v_1]; 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 __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); - let __ret: [G; OUT_643] = [__v_8]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_651] = [__v_8]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_3, __v_1]; 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_651] = { let __args: [G; IN_651] = [__v_3, __v_1]; 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 __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_4, __v_1]; 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_651] = { let __args: [G; IN_651] = [__v_4, __v_1]; 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 __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); - let __ret: [G; OUT_643] = [__v_8]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_651] = [__v_8]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_3, __v_1]; 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_651] = { let __args: [G; IN_651] = [__v_3, __v_1]; 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 __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_4, __v_1]; 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_651] = { let __args: [G; IN_651] = [__v_4, __v_1]; 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 __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_1]; 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_651] = { let __args: [G; IN_651] = [__v_5, __v_1]; 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 __v_8: G = __r_arr[0]; let __v_9: G = (__v_7 * __v_8); let __v_10: G = (__v_6 * __v_9); - let __ret: [G; OUT_643] = [__v_10]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_651] = [__v_10]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { 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_651] = [__v_6]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_1]; 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_651] = { let __args: [G; IN_651] = [__v_5, __v_1]; 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 __v_6: G = __r_arr[0]; - let __ret: [G; OUT_643] = [__v_6]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_651] = [__v_6]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55394,34 +56036,34 @@ fn aiur_fn_643( }) } -const INPUT_SIZE_644: usize = 3; -const IN_644: usize = 3; -const OUT_644: usize = 0; -fn aiur_fn_644( - inp: [G; IN_644], +const INPUT_SIZE_652: usize = 3; +const IN_652: usize = 3; +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_644], ExecError> { +) -> Result<[G; OUT_652], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_644] = []; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_1, __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_651] = { let __args: [G; IN_651] = [__v_1, __v_2]; 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 __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() }); } - let __ret: [G; OUT_644] = []; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55431,15 +56073,15 @@ fn aiur_fn_644( }) } -const INPUT_SIZE_645: usize = 2; -const IN_645: usize = 2; -const OUT_645: usize = 0; -fn aiur_fn_645( - inp: [G; IN_645], +const INPUT_SIZE_653: usize = 2; +const IN_653: usize = 2; +const OUT_653: usize = 0; +fn aiur_fn_653( + inp: [G; IN_653], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_645], ExecError> { +) -> Result<[G; OUT_653], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55449,28 +56091,28 @@ fn aiur_fn_645( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_645] = []; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = []; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_1]; 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_645] = []; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3, __v_1]; 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 __ret: [G; OUT_653] = []; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_1]; 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_645] = { let __args: [G; IN_645] = [__v_4, __v_1]; 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_645] = []; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3, __v_1]; 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_653] = { let __args: [G; IN_653] = [__v_4, __v_1]; 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 __ret: [G; OUT_653] = []; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_1]; 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_645] = { let __args: [G; IN_645] = [__v_4, __v_1]; 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_645] = []; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3, __v_1]; 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_653] = { let __args: [G; IN_653] = [__v_4, __v_1]; 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 __ret: [G; OUT_653] = []; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { @@ -55479,8 +56121,8 @@ fn aiur_fn_645( if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); } - let __ret: [G; OUT_645] = []; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = []; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55490,15 +56132,15 @@ fn aiur_fn_645( }) } -const INPUT_SIZE_646: usize = 2; -const IN_646: usize = 2; -const OUT_646: usize = 0; -fn aiur_fn_646( - inp: [G; IN_646], +const INPUT_SIZE_654: usize = 2; +const IN_654: usize = 2; +const OUT_654: usize = 0; +fn aiur_fn_654( + inp: [G; IN_654], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_646], ExecError> { +) -> Result<[G; OUT_654], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55508,15 +56150,15 @@ fn aiur_fn_646( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_646] = []; - record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_654] = []; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_1]; 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_646] = { let __args: [G; IN_646] = [__v_4, __v_1]; 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_646] = []; - record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3, __v_1]; 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_4, __v_1]; 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 __ret: [G; OUT_654] = []; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55526,15 +56168,15 @@ fn aiur_fn_646( }) } -const INPUT_SIZE_647: usize = 4; -const IN_647: usize = 4; -const OUT_647: usize = 0; -fn aiur_fn_647( - inp: [G; IN_647], +const INPUT_SIZE_655: usize = 4; +const IN_655: usize = 4; +const OUT_655: usize = 0; +fn aiur_fn_655( + inp: [G; IN_655], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_647], ExecError> { +) -> Result<[G; OUT_655], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55552,18 +56194,18 @@ fn aiur_fn_647( if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); } - let __ret: [G; OUT_647] = []; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_5, __v_2]; 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_647] = []; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_5, __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 __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_5]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -55584,55 +56226,55 @@ fn aiur_fn_647( if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); } - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_6, __v_2]; 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_647] = []; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_2]; 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 __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_5, __v_1, __v_2, __v_3]; 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_647] = { let __args: [G; IN_647] = [__v_6, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_647] = []; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_1, __v_2, __v_3]; 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_655] = { let __args: [G; IN_655] = [__v_6, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_5, __v_1, __v_2, __v_3]; 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_655] = { let __args: [G; IN_655] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_647] = []; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_5, __v_1, __v_2, __v_3]; 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_655] = { let __args: [G; IN_655] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_647] = []; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_5, __v_1, __v_2, __v_3]; 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_647] = { let __args: [G; IN_647] = [__v_6, __v_1, __v_2, __v_3]; 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_655] = { let __args: [G; IN_655] = [__v_5, __v_1, __v_2, __v_3]; 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_655] = { let __args: [G; IN_655] = [__v_6, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_7, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_647] = []; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_7, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_647] = []; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_7, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_647] = []; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_7, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55642,15 +56284,15 @@ fn aiur_fn_647( }) } -const INPUT_SIZE_648: usize = 12; -const IN_648: usize = 12; -const OUT_648: usize = 0; -fn aiur_fn_648( - inp: [G; IN_648], +const INPUT_SIZE_656: usize = 12; +const IN_656: usize = 12; +const OUT_656: usize = 0; +fn aiur_fn_656( + inp: [G; IN_656], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_648], ExecError> { +) -> Result<[G; OUT_656], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55669,53 +56311,53 @@ fn aiur_fn_648( let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __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[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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_13, __v_14, __v_12, __v_11]; 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_655] = { let __args: [G; IN_655] = [__v_13, __v_14, __v_12, __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)? } }; match __v_0.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_648] = []; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_3, __v_15, __v_12, __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 __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_648] = []; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_3, __v_15, __v_12, __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 __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_648] = []; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_3, __v_15, __v_12, __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 __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_7, __v_12, __v_11]; 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_648] = []; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_7, __v_12, __v_11]; 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 __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_648] = []; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); 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_657: usize = 3; +const IN_657: usize = 3; +const OUT_657: usize = 0; +fn aiur_fn_657( + inp: [G; IN_657], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_649], 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]; @@ -55728,18 +56370,18 @@ 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_657] = []; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_6, __v_8, __v_1, __v_2]; 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_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_655] = { let __args: [G; IN_655] = [__v_6, __v_8, __v_1, __v_2]; 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_657] = { let __args: [G; IN_657] = [__v_7, __v_1, __v_2]; 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 __ret: [G; OUT_657] = []; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55751,15 +56393,15 @@ fn aiur_fn_649( }) } -const INPUT_SIZE_650: usize = 2; -const IN_650: usize = 2; -const OUT_650: usize = 0; -fn aiur_fn_650( - inp: [G; IN_650], +const INPUT_SIZE_658: usize = 2; +const IN_658: usize = 2; +const OUT_658: usize = 0; +fn aiur_fn_658( + inp: [G; IN_658], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_650], 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]; @@ -55768,7 +56410,7 @@ fn aiur_fn_650( let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_2, __v_1, __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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __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_726] = { let __args: [G; IN_726] = [__v_0, __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_5: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -55799,9 +56441,9 @@ fn aiur_fn_650( return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); } let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_21]; 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_726] = { let __args: [G; IN_726] = [__v_11, __v_21]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __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_726] = { let __args: [G; IN_726] = [__v_1, __v_22]; 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_23: G = __r_arr[0]; let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; 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_24: G = __r_arr[0]; @@ -55811,8 +56453,8 @@ fn aiur_fn_650( if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64() }); } - let __ret: [G; OUT_650] = []; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = []; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55822,15 +56464,15 @@ fn aiur_fn_650( }) } -const INPUT_SIZE_651: usize = 14; -const IN_651: usize = 14; -const OUT_651: usize = 0; -fn aiur_fn_651( - inp: [G; IN_651], +const INPUT_SIZE_659: usize = 14; +const IN_659: usize = 14; +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_651], 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]; @@ -55846,8 +56488,8 @@ fn aiur_fn_651( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_642] = { let __args: [G; IN_642] = [__v_0, __v_1, __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[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_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_650] = { let __args: [G; IN_650] = [__v_0, __v_1, __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[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]; match __v_0.as_canonical_u64() { 0u64 => { @@ -55856,9 +56498,9 @@ fn aiur_fn_651( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_14, __v_2, __v_12]; 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 __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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 __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -55867,14 +56509,14 @@ fn aiur_fn_651( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_14, __v_2, __v_12]; 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_644] = { let __args: [G; IN_644] = [__v_14, __v_3, __v_12]; 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_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_652] = { let __args: [G; IN_652] = [__v_14, __v_3, __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_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { @@ -55892,14 +56534,14 @@ fn aiur_fn_651( if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); } - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_14, __v_2, __v_12]; 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_644] = { let __args: [G; IN_644] = [__v_14, __v_3, __v_12]; 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_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_652] = { let __args: [G; IN_652] = [__v_14, __v_3, __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_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_2, __v_26, __v_12, __v_13]; 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 __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { @@ -55908,12 +56550,12 @@ fn aiur_fn_651( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_14, __v_2, __v_12]; 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_644] = { let __args: [G; IN_644] = [__v_14, __v_3, __v_12]; 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_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_652] = { let __args: [G; IN_652] = [__v_14, __v_3, __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)? } }; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -55921,8 +56563,8 @@ fn aiur_fn_651( let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55936,12 +56578,12 @@ fn aiur_fn_651( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_14, __v_2, __v_12]; 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_718] = { let __args: [G; IN_718] = [__v_13, __v_11]; 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_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_726] = { let __args: [G; IN_726] = [__v_13, __v_11]; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_19, __v_3, __v_1, __v_2, __v_12, __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 __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; 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)); return Ok(__ret); }, 5u64 => { @@ -55950,18 +56592,18 @@ fn aiur_fn_651( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_14, __v_2, __v_12]; 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_587] = { let __args: [G; IN_587] = [__v_11, __v_2, __v_3, __v_4, __v_10, __v_12, __v_13]; 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_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_595] = { let __args: [G; IN_595] = [__v_11, __v_2, __v_3, __v_4, __v_10, __v_12, __v_13]; 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_529] = { let __args: [G; IN_529] = [__v_11, __v_12]; 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 __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_19, __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_587] = { let __args: [G; IN_587] = [__v_19, __v_12]; 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_498] = { let __args: [G; IN_498] = [__v_5, __v_3, __v_19, __v_12]; 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_20: G = __r_arr[0]; if (__v_6 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); } - let __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { @@ -55970,9 +56612,9 @@ fn aiur_fn_651( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_14, __v_2, __v_12]; 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_558] = { let __args: [G; IN_558] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_718] = { let __args: [G; IN_718] = [__v_12, __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_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_561] = { let __args: [G; IN_561] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_726] = { let __args: [G; IN_726] = [__v_12, __v_3]; 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_19: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -55991,7 +56633,7 @@ fn aiur_fn_651( if (__v_5 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); } - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_22, __v_2, __v_23, __v_12, __v_13]; 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_597] = { let __args: [G; IN_597] = [__v_22, __v_2, __v_23, __v_12, __v_13]; 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_484] = { let __args: [G; IN_484] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21]; 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_31: G = (__v_23 + __v_24); let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_22, __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)? } }; @@ -56004,8 +56646,8 @@ fn aiur_fn_651( 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_492] = { let __args: [G; IN_492] = [__v_2, __v_5, __v_3, __v_38, __v_12, __v_13]; 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 __ret: [G; OUT_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56019,10 +56661,10 @@ fn aiur_fn_651( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_14, __v_2, __v_12]; 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_560] = { let __args: [G; IN_560] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; 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_651] = []; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_564] = { let __args: [G; IN_564] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; 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_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56032,15 +56674,15 @@ fn aiur_fn_651( }) } -const INPUT_SIZE_652: usize = 6; -const IN_652: usize = 6; -const OUT_652: usize = 0; -fn aiur_fn_652( - inp: [G; IN_652], +const INPUT_SIZE_660: usize = 6; +const IN_660: usize = 6; +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_652], 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]; @@ -56084,7 +56726,7 @@ fn aiur_fn_652( if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); } - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_4, __v_5]; 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 __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_4, __v_5]; 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_9: G = G::from_u64(2); let __v_10: G = G::from_u64(6); break '__mc_0 [__v_9, __v_10]; @@ -56113,27 +56755,27 @@ fn aiur_fn_652( return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); } let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3, __v_7, __v_8]; 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_661] = { let __args: [G; IN_661] = [__v_3, __v_7, __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 __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); } - let __ret: [G; OUT_652] = []; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_660] = []; + record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_653: usize = 3; -const IN_653: usize = 3; -const OUT_653: usize = 1; -fn aiur_fn_653( - inp: [G; IN_653], +const INPUT_SIZE_661: usize = 3; +const IN_661: usize = 3; +const OUT_661: usize = 1; +fn aiur_fn_661( + inp: [G; IN_661], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_653], 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]; @@ -56142,8 +56784,8 @@ fn aiur_fn_653( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_653] = [__v_4]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_661] = [__v_4]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56156,16 +56798,16 @@ fn aiur_fn_653( 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_6, __v_1, __v_9]; 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_661] = { let __args: [G; IN_661] = [__v_6, __v_1, __v_9]; 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 __v_10: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_10]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_661] = [__v_10]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_653] = [__v_8]; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_661] = [__v_8]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -56174,37 +56816,37 @@ fn aiur_fn_653( }) } -const INPUT_SIZE_654: usize = 3; -const IN_654: usize = 3; -const OUT_654: usize = 0; -fn aiur_fn_654( - inp: [G; IN_654], +const INPUT_SIZE_662: usize = 3; +const IN_662: usize = 3; +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_654], ExecError> { +) -> Result<[G; OUT_662], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_1]; 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_632] = { let __args: [G; IN_632] = [__v_1]; 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_3: G = G::from_u64(0); - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_654] = []; - record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_2, __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 __ret: [G; OUT_662] = []; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_655: usize = 4; -const IN_655: usize = 4; -const OUT_655: usize = 0; -fn aiur_fn_655( - inp: [G; IN_655], +const INPUT_SIZE_663: usize = 4; +const IN_663: usize = 4; +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_655], 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]; @@ -56216,8 +56858,8 @@ fn aiur_fn_655( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_663] = []; + record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -56233,12 +56875,12 @@ fn aiur_fn_655( let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_3, __v_1, __v_2]; 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_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_3, __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_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_6, __v_1, __v_2, __v_19]; 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 __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_6, __v_1, __v_2, __v_19]; 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 __ret: [G; OUT_663] = []; + record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56248,15 +56890,15 @@ fn aiur_fn_655( }) } -const INPUT_SIZE_656: usize = 1; -const IN_656: usize = 1; -const OUT_656: usize = 3; -fn aiur_fn_656( - inp: [G; IN_656], +const INPUT_SIZE_664: usize = 1; +const IN_664: usize = 1; +const OUT_664: usize = 3; +fn aiur_fn_664( + inp: [G; IN_664], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_656], ExecError> { +) -> Result<[G; OUT_664], 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)? } }; @@ -56266,8 +56908,8 @@ fn aiur_fn_656( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_656] = [__v_3, __v_4, __v_2]; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_664] = [__v_3, __v_4, __v_2]; + record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -56275,8 +56917,8 @@ fn aiur_fn_656( 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_656] = [__v_5, __v_3, __v_4]; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_664] = [__v_5, __v_3, __v_4]; + record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56286,15 +56928,15 @@ fn aiur_fn_656( }) } -const INPUT_SIZE_657: usize = 2; -const IN_657: usize = 2; -const OUT_657: usize = 10; -fn aiur_fn_657( - inp: [G; IN_657], +const INPUT_SIZE_665: usize = 2; +const IN_665: usize = 2; +const OUT_665: usize = 10; +fn aiur_fn_665( + inp: [G; IN_665], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_657], 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]; @@ -56302,8 +56944,8 @@ fn aiur_fn_657( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_657] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_665] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56318,23 +56960,23 @@ fn aiur_fn_657( 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_657] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_665] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_658: usize = 2; -const IN_658: usize = 2; -const OUT_658: usize = 3; -fn aiur_fn_658( - inp: [G; IN_658], +const INPUT_SIZE_666: usize = 2; +const IN_666: usize = 2; +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_658], ExecError> { +) -> Result<[G; OUT_666], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56342,8 +56984,8 @@ fn aiur_fn_658( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_658] = [__v_2, __v_3, __v_1]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_666] = [__v_2, __v_3, __v_1]; + record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56351,23 +56993,23 @@ fn aiur_fn_658( 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_658] = [__v_4, __v_2, __v_3]; - record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_666] = [__v_4, __v_2, __v_3]; + record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_659: usize = 2; -const IN_659: usize = 2; -const OUT_659: usize = 3; -fn aiur_fn_659( - inp: [G; IN_659], +const INPUT_SIZE_667: usize = 2; +const IN_667: usize = 2; +const OUT_667: usize = 3; +fn aiur_fn_667( + inp: [G; IN_667], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_659], 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]; @@ -56375,8 +57017,8 @@ fn aiur_fn_659( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_659] = [__v_2, __v_3, __v_1]; - record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_667] = [__v_2, __v_3, __v_1]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56384,23 +57026,23 @@ fn aiur_fn_659( 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_659] = [__v_4, __v_2, __v_3]; - record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_667] = [__v_4, __v_2, __v_3]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_660: usize = 2; -const IN_660: usize = 2; -const OUT_660: usize = 3; -fn aiur_fn_660( - inp: [G; IN_660], +const INPUT_SIZE_668: usize = 2; +const IN_668: usize = 2; +const OUT_668: usize = 3; +fn aiur_fn_668( + inp: [G; IN_668], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_660], 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]; @@ -56408,8 +57050,8 @@ fn aiur_fn_660( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_660] = [__v_2, __v_3, __v_1]; - record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_668] = [__v_2, __v_3, __v_1]; + record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56420,22 +57062,22 @@ fn aiur_fn_660( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_660] = [__v_4, __v_5, __v_3]; - record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_668] = [__v_4, __v_5, __v_3]; + record.function_queries[668].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_660] = [__v_4, __v_5, __v_3]; - record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_668] = [__v_4, __v_5, __v_3]; + record.function_queries[668].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_660] = [__v_4, __v_5, __v_3]; - record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_668] = [__v_4, __v_5, __v_3]; + record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56447,15 +57089,15 @@ fn aiur_fn_660( }) } -const INPUT_SIZE_661: usize = 2; -const IN_661: usize = 2; -const OUT_661: usize = 3; -fn aiur_fn_661( - inp: [G; IN_661], +const INPUT_SIZE_669: usize = 2; +const IN_669: usize = 2; +const OUT_669: usize = 3; +fn aiur_fn_669( + inp: [G; IN_669], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_661], 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]; @@ -56463,8 +57105,8 @@ fn aiur_fn_661( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_661] = [__v_2, __v_3, __v_1]; - record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_669] = [__v_2, __v_3, __v_1]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56475,29 +57117,29 @@ fn aiur_fn_661( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_661] = [__v_4, __v_5, __v_3]; - record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_669] = [__v_4, __v_5, __v_3]; + record.function_queries[669].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_661] = [__v_4, __v_5, __v_3]; - record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_669] = [__v_4, __v_5, __v_3]; + record.function_queries[669].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_661] = [__v_4, __v_5, __v_3]; - record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_669] = [__v_4, __v_5, __v_3]; + record.function_queries[669].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_661] = [__v_4, __v_5, __v_3]; - record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_669] = [__v_4, __v_5, __v_3]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56509,15 +57151,15 @@ fn aiur_fn_661( }) } -const INPUT_SIZE_662: usize = 9; -const IN_662: usize = 9; -const OUT_662: usize = 2; -fn aiur_fn_662( - inp: [G; IN_662], +const INPUT_SIZE_670: usize = 9; +const IN_670: usize = 9; +const OUT_670: usize = 2; +fn aiur_fn_670( + inp: [G; IN_670], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_662], 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]; @@ -56535,8 +57177,8 @@ fn aiur_fn_662( 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_662] = [__v_12, __v_0]; - record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_670] = [__v_12, __v_0]; + record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56568,28 +57210,28 @@ fn aiur_fn_662( 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_662] = { let __args: [G; IN_662] = [__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[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_670] = { let __args: [G; IN_670] = [__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[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 __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_662] = [__v_39, __v_37]; - record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_670] = [__v_39, __v_37]; + record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_663: usize = 2; -const IN_663: usize = 2; -const OUT_663: usize = 3; -fn aiur_fn_663( - inp: [G; IN_663], +const INPUT_SIZE_671: usize = 2; +const IN_671: usize = 2; +const OUT_671: usize = 3; +fn aiur_fn_671( + inp: [G; IN_671], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_663], 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]; @@ -56597,8 +57239,8 @@ fn aiur_fn_663( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_663] = [__v_2, __v_3, __v_1]; - record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_671] = [__v_2, __v_3, __v_1]; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56612,27 +57254,27 @@ fn aiur_fn_663( 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_662] = { let __args: [G; IN_662] = [__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[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_670] = { let __args: [G; IN_670] = [__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[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 __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_663] = [__v_13, __v_11, __v_12]; - record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_671] = [__v_13, __v_11, __v_12]; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_664: usize = 1; -const IN_664: usize = 1; -const OUT_664: usize = 41; -fn aiur_fn_664( - inp: [G; IN_664], +const INPUT_SIZE_672: usize = 1; +const IN_672: usize = 1; +const OUT_672: usize = 41; +fn aiur_fn_672( + inp: [G; IN_672], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_664], ExecError> { +) -> Result<[G; OUT_672], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -56654,11 +57296,11 @@ fn aiur_fn_664( 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_659] = { let __args: [G; IN_659] = [__v_10, __v_9]; 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_667] = { let __args: [G; IN_667] = [__v_10, __v_9]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_11, __v_20]; 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_665] = { let __args: [G; IN_665] = [__v_11, __v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -56669,7 +57311,7 @@ fn aiur_fn_664( 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_657] = { let __args: [G; IN_657] = [__v_12, __v_30]; 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_665] = { let __args: [G; IN_665] = [__v_12, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -56680,7 +57322,7 @@ fn aiur_fn_664( 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_657] = { let __args: [G; IN_657] = [__v_13, __v_40]; 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_665] = { let __args: [G; IN_665] = [__v_13, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -56691,7 +57333,7 @@ fn aiur_fn_664( 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_657] = { let __args: [G; IN_657] = [__v_14, __v_50]; 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_665] = { let __args: [G; IN_665] = [__v_14, __v_50]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -56702,25 +57344,25 @@ fn aiur_fn_664( 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_658] = { let __args: [G; IN_658] = [__v_15, __v_60]; 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_666] = { let __args: [G; IN_666] = [__v_15, __v_60]; 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_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __ret: [G; OUT_664] = [__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[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_672] = [__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[672].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 = 49; -fn aiur_fn_665( - inp: [G; IN_665], +const INPUT_SIZE_673: usize = 1; +const IN_673: usize = 1; +const OUT_673: usize = 49; +fn aiur_fn_673( + inp: [G; IN_673], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_665], 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_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -56733,7 +57375,7 @@ fn aiur_fn_665( 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_664] = { let __args: [G; IN_664] = [__v_9]; 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_672] = { let __args: [G; IN_672] = [__v_9]; 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 __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -56775,21 +57417,21 @@ fn aiur_fn_665( 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_665] = [__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[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_673] = [__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[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_666: usize = 9; -const IN_666: usize = 9; -const OUT_666: usize = 2; -fn aiur_fn_666( - inp: [G; IN_666], +const INPUT_SIZE_674: usize = 9; +const IN_674: usize = 9; +const OUT_674: usize = 2; +fn aiur_fn_674( + inp: [G; IN_674], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_666], 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]; @@ -56807,12 +57449,12 @@ fn aiur_fn_666( 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_666] = [__v_12, __v_0]; - record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_674] = [__v_12, __v_0]; + record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_0]; 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_673] = { let __args: [G; IN_673] = [__v_0]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -56871,28 +57513,28 @@ fn aiur_fn_666( 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_666] = { let __args: [G; IN_666] = [__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[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_674] = { let __args: [G; IN_674] = [__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[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_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_666] = [__v_70, __v_68]; - record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_674] = [__v_70, __v_68]; + record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_667: usize = 2; -const IN_667: usize = 2; -const OUT_667: usize = 3; -fn aiur_fn_667( - inp: [G; IN_667], +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_667], 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]; @@ -56900,8 +57542,8 @@ fn aiur_fn_667( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_667] = [__v_2, __v_3, __v_1]; - record.function_queries[667].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)); return Ok(__ret); }, _ => { @@ -56915,27 +57557,27 @@ fn aiur_fn_667( 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_666] = { let __args: [G; IN_666] = [__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[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_674] = { let __args: [G; IN_674] = [__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[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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_667] = [__v_13, __v_11, __v_12]; - record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_675] = [__v_13, __v_11, __v_12]; + record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_668: usize = 1; -const IN_668: usize = 1; -const OUT_668: usize = 55; -fn aiur_fn_668( - inp: [G; IN_668], +const INPUT_SIZE_676: usize = 1; +const IN_676: usize = 1; +const OUT_676: usize = 55; +fn aiur_fn_676( + inp: [G; IN_676], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_668], ExecError> { +) -> Result<[G; OUT_676], 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)? } }; @@ -56971,15 +57613,15 @@ fn aiur_fn_668( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; 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_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; 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_668] = { let __args: [G; IN_668] = [__v_13, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_14, __v_33]; 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_665] = { let __args: [G; IN_665] = [__v_14, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -56990,34 +57632,34 @@ fn aiur_fn_668( 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_658] = { let __args: [G; IN_658] = [__v_15, __v_43]; 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_666] = { let __args: [G; IN_666] = [__v_15, __v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_46]; 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_666] = { let __args: [G; IN_666] = [__v_16, __v_46]; 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_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_668] = [__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[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_676] = [__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[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_12, __v_11]; 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_667] = { let __args: [G; IN_667] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_30]; 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_667] = { let __args: [G; IN_667] = [__v_13, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_33]; 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_667] = { let __args: [G; IN_667] = [__v_14, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_15, __v_36]; 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_665] = { let __args: [G; IN_665] = [__v_15, __v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -57028,7 +57670,7 @@ fn aiur_fn_668( let __v_44: G = __r_arr[7]; let __v_45: G = __r_arr[8]; let __v_46: G = __r_arr[9]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_16, __v_46]; 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_665] = { let __args: [G; IN_665] = [__v_16, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -57039,7 +57681,7 @@ fn aiur_fn_668( let __v_54: G = __r_arr[7]; let __v_55: G = __r_arr[8]; let __v_56: G = __r_arr[9]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_17, __v_56]; 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_665] = { let __args: [G; IN_665] = [__v_17, __v_56]; 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_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -57050,7 +57692,7 @@ fn aiur_fn_668( let __v_64: G = __r_arr[7]; let __v_65: G = __r_arr[8]; let __v_66: G = __r_arr[9]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_18, __v_66]; 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_665] = { let __args: [G; IN_665] = [__v_18, __v_66]; 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_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = __r_arr[2]; @@ -57061,30 +57703,30 @@ fn aiur_fn_668( let __v_74: G = __r_arr[7]; let __v_75: G = __r_arr[8]; let __v_76: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_19, __v_76]; 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_666] = { let __args: [G; IN_666] = [__v_19, __v_76]; 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_77: G = __r_arr[0]; let __v_78: G = __r_arr[1]; let __v_79: G = __r_arr[2]; - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_20, __v_79]; 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_675] = { let __args: [G; IN_675] = [__v_20, __v_79]; 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_80: G = __r_arr[0]; let __v_81: G = __r_arr[1]; let __v_82: G = __r_arr[2]; let __v_83: G = G::from_u64(1); let __v_84: G = G::from_u64(0); - let __ret: [G; OUT_668] = [__v_83, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_37, __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_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_77, __v_78, __v_80, __v_81, __v_84, __v_84, __v_84, __v_84, __v_84, __v_84, __v_84, __v_82]; - record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_676] = [__v_83, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_37, __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_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_77, __v_78, __v_80, __v_81, __v_84, __v_84, __v_84, __v_84, __v_84, __v_84, __v_84, __v_82]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_12, __v_11]; 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_667] = { let __args: [G; IN_667] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_30]; 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_667] = { let __args: [G; IN_667] = [__v_13, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_14, __v_33]; 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_665] = { let __args: [G; IN_665] = [__v_14, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -57095,7 +57737,7 @@ fn aiur_fn_668( 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_657] = { let __args: [G; IN_657] = [__v_15, __v_43]; 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_665] = { let __args: [G; IN_665] = [__v_15, __v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -57106,7 +57748,7 @@ fn aiur_fn_668( 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_657] = { let __args: [G; IN_657] = [__v_16, __v_53]; 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_665] = { let __args: [G; IN_665] = [__v_16, __v_53]; 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_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -57117,7 +57759,7 @@ fn aiur_fn_668( 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_657] = { let __args: [G; IN_657] = [__v_17, __v_63]; 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_665] = { let __args: [G; IN_665] = [__v_17, __v_63]; 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_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -57128,7 +57770,7 @@ fn aiur_fn_668( 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_657] = { let __args: [G; IN_657] = [__v_18, __v_73]; 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_665] = { let __args: [G; IN_665] = [__v_18, __v_73]; 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_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -57139,17 +57781,17 @@ fn aiur_fn_668( 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_658] = { let __args: [G; IN_658] = [__v_19, __v_83]; 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_666] = { let __args: [G; IN_666] = [__v_19, __v_83]; 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_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_20, __v_86]; 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_671] = { let __args: [G; IN_671] = [__v_20, __v_86]; 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 __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_668] = [__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[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_676] = [__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[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57159,15 +57801,15 @@ fn aiur_fn_668( }) } -const INPUT_SIZE_669: usize = 1; -const IN_669: usize = 1; -const OUT_669: usize = 63; -fn aiur_fn_669( - inp: [G; IN_669], +const INPUT_SIZE_677: usize = 1; +const IN_677: usize = 1; +const OUT_677: usize = 63; +fn aiur_fn_677( + inp: [G; IN_677], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_669], ExecError> { +) -> Result<[G; OUT_677], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -57180,7 +57822,7 @@ fn aiur_fn_669( 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_668] = { let __args: [G; IN_668] = [__v_9]; 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_676] = { let __args: [G; IN_676] = [__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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57236,21 +57878,21 @@ fn aiur_fn_669( 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_669] = [__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[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_677] = [__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[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_670: usize = 9; -const IN_670: usize = 9; -const OUT_670: usize = 2; -fn aiur_fn_670( - inp: [G; IN_670], +const INPUT_SIZE_678: usize = 9; +const IN_678: usize = 9; +const OUT_678: usize = 2; +fn aiur_fn_678( + inp: [G; IN_678], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_670], 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]; @@ -57268,12 +57910,12 @@ fn aiur_fn_670( 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_670] = [__v_12, __v_0]; - record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_12, __v_0]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0]; 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_677] = { let __args: [G; IN_677] = [__v_0]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57346,28 +57988,28 @@ fn aiur_fn_670( 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_670] = { let __args: [G; IN_670] = [__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[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_678] = { let __args: [G; IN_678] = [__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[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_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_670] = [__v_84, __v_82]; - record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_84, __v_82]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_671: usize = 1; -const IN_671: usize = 1; -const OUT_671: usize = 55; -fn aiur_fn_671( - inp: [G; IN_671], +const INPUT_SIZE_679: usize = 1; +const IN_679: usize = 1; +const OUT_679: usize = 55; +fn aiur_fn_679( + inp: [G; IN_679], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_671], ExecError> { +) -> Result<[G; OUT_679], 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)? } }; @@ -57403,15 +58045,15 @@ fn aiur_fn_671( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; 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_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; 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_668] = { let __args: [G; IN_668] = [__v_13, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_14, __v_33]; 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_665] = { let __args: [G; IN_665] = [__v_14, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -57422,30 +58064,30 @@ fn aiur_fn_671( 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_658] = { let __args: [G; IN_658] = [__v_15, __v_43]; 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_666] = { let __args: [G; IN_666] = [__v_15, __v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_46]; 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_666] = { let __args: [G; IN_666] = [__v_16, __v_46]; 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_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_671] = [__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[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_12, __v_11]; 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_667] = { let __args: [G; IN_667] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_30]; 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_667] = { let __args: [G; IN_667] = [__v_13, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_14, __v_33]; 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_665] = { let __args: [G; IN_665] = [__v_14, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -57456,7 +58098,7 @@ fn aiur_fn_671( 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_657] = { let __args: [G; IN_657] = [__v_15, __v_43]; 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_665] = { let __args: [G; IN_665] = [__v_15, __v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -57467,7 +58109,7 @@ fn aiur_fn_671( 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_657] = { let __args: [G; IN_657] = [__v_16, __v_53]; 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_665] = { let __args: [G; IN_665] = [__v_16, __v_53]; 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_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -57478,7 +58120,7 @@ fn aiur_fn_671( 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_657] = { let __args: [G; IN_657] = [__v_17, __v_63]; 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_665] = { let __args: [G; IN_665] = [__v_17, __v_63]; 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_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -57489,7 +58131,7 @@ fn aiur_fn_671( 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_657] = { let __args: [G; IN_657] = [__v_18, __v_73]; 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_665] = { let __args: [G; IN_665] = [__v_18, __v_73]; 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_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -57500,25 +58142,25 @@ fn aiur_fn_671( 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_658] = { let __args: [G; IN_658] = [__v_19, __v_83]; 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_666] = { let __args: [G; IN_666] = [__v_19, __v_83]; 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_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_20, __v_86]; 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_671] = { let __args: [G; IN_671] = [__v_20, __v_86]; 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 __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_671] = [__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[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_12, __v_11]; 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_667] = { let __args: [G; IN_667] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_13, __v_30]; 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_665] = { let __args: [G; IN_665] = [__v_13, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -57529,22 +58171,22 @@ fn aiur_fn_671( 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_658] = { let __args: [G; IN_658] = [__v_14, __v_40]; 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_666] = { let __args: [G; IN_666] = [__v_14, __v_40]; 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_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_671] = [__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[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_12, __v_11]; 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_669] = { let __args: [G; IN_669] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_13, __v_30]; 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_665] = { let __args: [G; IN_665] = [__v_13, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -57555,18 +58197,18 @@ fn aiur_fn_671( 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_658] = { let __args: [G; IN_658] = [__v_14, __v_40]; 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_666] = { let __args: [G; IN_666] = [__v_14, __v_40]; 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_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_671] = [__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[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_12, __v_11]; 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_665] = { let __args: [G; IN_665] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -57577,7 +58219,7 @@ fn aiur_fn_671( 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_657] = { let __args: [G; IN_657] = [__v_13, __v_37]; 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_665] = { let __args: [G; IN_665] = [__v_13, __v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -57588,18 +58230,18 @@ fn aiur_fn_671( 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_658] = { let __args: [G; IN_658] = [__v_14, __v_47]; 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_666] = { let __args: [G; IN_666] = [__v_14, __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]; let __v_51: G = G::from_u64(4); let __v_52: G = G::from_u64(0); - let __ret: [G; OUT_671] = [__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[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_12, __v_11]; 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_665] = { let __args: [G; IN_665] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -57610,18 +58252,18 @@ fn aiur_fn_671( 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_658] = { let __args: [G; IN_658] = [__v_13, __v_37]; 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_666] = { let __args: [G; IN_666] = [__v_13, __v_37]; 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_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_671] = [__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[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_12, __v_11]; 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_665] = { let __args: [G; IN_665] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -57632,18 +58274,18 @@ fn aiur_fn_671( 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_658] = { let __args: [G; IN_658] = [__v_13, __v_37]; 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_666] = { let __args: [G; IN_666] = [__v_13, __v_37]; 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_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_671] = [__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[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_12, __v_11]; 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_665] = { let __args: [G; IN_665] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -57654,14 +58296,14 @@ fn aiur_fn_671( 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_658] = { let __args: [G; IN_658] = [__v_13, __v_37]; 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_666] = { let __args: [G; IN_666] = [__v_13, __v_37]; 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_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_671] = [__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[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { @@ -57683,7 +58325,7 @@ fn aiur_fn_671( 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_670] = { let __args: [G; IN_670] = [__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[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_678] = { let __args: [G; IN_678] = [__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[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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -57697,8 +58339,8 @@ fn aiur_fn_671( 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_671] = [__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[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57708,15 +58350,15 @@ fn aiur_fn_671( }) } -const INPUT_SIZE_672: usize = 1; -const IN_672: usize = 1; -const OUT_672: usize = 57; -fn aiur_fn_672( - inp: [G; IN_672], +const INPUT_SIZE_680: usize = 1; +const IN_680: usize = 1; +const OUT_680: usize = 57; +fn aiur_fn_680( + inp: [G; IN_680], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_672], ExecError> { +) -> Result<[G; OUT_680], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; @@ -57742,49 +58384,49 @@ fn aiur_fn_672( let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_15]; 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_664] = { let __args: [G; IN_664] = [__v_15]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_672] = [__v_19, __v_12, __v_14, __v_16, __v_17, __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_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_18]; - record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_680] = [__v_19, __v_12, __v_14, __v_16, __v_17, __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_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_18]; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_13]; 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_664] = { let __args: [G; IN_664] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_672] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; - record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_680] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_13]; 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_664] = { let __args: [G; IN_664] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_672] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; - record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_680] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__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 __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -57841,8 +58483,8 @@ fn aiur_fn_672( let __v_67: G = __r_arr[53]; let __v_68: G = __r_arr[54]; let __v_69: G = G::from_u64(3); - let __ret: [G; OUT_672] = [__v_69, __v_12, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __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]; - record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_680] = [__v_69, __v_12, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __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]; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { @@ -57854,8 +58496,8 @@ fn aiur_fn_672( let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(4); let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_672] = [__v_16, __v_12, __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_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[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_680] = [__v_16, __v_12, __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_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[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57865,15 +58507,15 @@ fn aiur_fn_672( }) } -const INPUT_SIZE_673: usize = 32; -const IN_673: usize = 32; -const OUT_673: usize = 56; -fn aiur_fn_673( - inp: [G; IN_673], +const INPUT_SIZE_681: usize = 32; +const IN_681: usize = 32; +const OUT_681: usize = 56; +fn aiur_fn_681( + inp: [G; IN_681], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_673], 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]; @@ -57915,7 +58557,7 @@ fn aiur_fn_673( let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_35, __v_33, __v_34]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_36, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[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 __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_36]; 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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -57988,21 +58630,21 @@ fn aiur_fn_673( if (__v_96 != __v_98) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_98.as_canonical_u64() }); } - let __ret: [G; OUT_673] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92]; - record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_681] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92]; + record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_674: usize = 1; -const IN_674: usize = 1; -const OUT_674: usize = 1; -fn aiur_fn_674( - inp: [G; IN_674], +const INPUT_SIZE_682: usize = 1; +const IN_682: usize = 1; +const OUT_682: usize = 1; +fn aiur_fn_682( + inp: [G; IN_682], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_674], ExecError> { +) -> Result<[G; OUT_682], 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 }; @@ -58031,40 +58673,40 @@ fn aiur_fn_674( let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_674] = [__v_23]; - record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__v_23]; + record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_675: usize = 1; -const IN_675: usize = 1; -const OUT_675: usize = 1; -fn aiur_fn_675( - inp: [G; IN_675], +const INPUT_SIZE_683: usize = 1; +const IN_683: usize = 1; +const OUT_683: usize = 1; +fn aiur_fn_683( + inp: [G; IN_683], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_675], ExecError> { +) -> Result<[G; OUT_683], 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_675] = [__v_1]; - record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_683] = [__v_1]; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_675] = [__v_1]; - record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_683] = [__v_1]; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_675] = [__v_1]; - record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_683] = [__v_1]; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58074,35 +58716,35 @@ fn aiur_fn_675( }) } -const INPUT_SIZE_676: usize = 3; -const IN_676: usize = 3; -const OUT_676: usize = 0; -fn aiur_fn_676( - inp: [G; IN_676], +const INPUT_SIZE_684: usize = 3; +const IN_684: usize = 3; +const OUT_684: usize = 0; +fn aiur_fn_684( + inp: [G; IN_684], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_676], ExecError> { +) -> Result<[G; OUT_684], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_676] = []; - record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_684] = []; + record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0]; 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_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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_2]; 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_683] = { let __args: [G; IN_683] = [__v_2]; 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_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() }); } - let __ret: [G; OUT_676] = []; - record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_684] = []; + record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58112,23 +58754,23 @@ fn aiur_fn_676( }) } -const INPUT_SIZE_677: usize = 3; -const IN_677: usize = 3; -const OUT_677: usize = 0; -fn aiur_fn_677( - inp: [G; IN_677], +const INPUT_SIZE_685: usize = 3; +const IN_685: usize = 3; +const OUT_685: usize = 0; +fn aiur_fn_685( + inp: [G; IN_685], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_677], ExecError> { +) -> Result<[G; OUT_685], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_677] = []; - record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_685] = []; + record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -58139,8 +58781,8 @@ fn aiur_fn_677( if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); } - let __ret: [G; OUT_677] = []; - record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_685] = []; + record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58150,31 +58792,31 @@ fn aiur_fn_677( }) } -const INPUT_SIZE_678: usize = 3; -const IN_678: usize = 3; -const OUT_678: usize = 0; -fn aiur_fn_678( - inp: [G; IN_678], +const INPUT_SIZE_686: usize = 3; +const IN_686: usize = 3; +const OUT_686: usize = 0; +fn aiur_fn_686( + inp: [G; IN_686], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_678], ExecError> { +) -> Result<[G; OUT_686], ExecError> { stacker::maybe_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_678] = []; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_686] = []; + record.function_queries[686].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() }); } - let __ret: [G; OUT_678] = []; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_686] = []; + record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58184,15 +58826,15 @@ fn aiur_fn_678( }) } -const INPUT_SIZE_679: usize = 17; -const IN_679: usize = 17; -const OUT_679: usize = 0; -fn aiur_fn_679( - inp: [G; IN_679], +const INPUT_SIZE_687: usize = 17; +const IN_687: usize = 17; +const OUT_687: usize = 0; +fn aiur_fn_687( + inp: [G; IN_687], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_679], 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]; @@ -58213,8 +58855,8 @@ fn aiur_fn_679( let __v_16: G = inp[16]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_679] = []; - record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_687] = []; + record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -58242,8 +58884,8 @@ fn aiur_fn_679( if (__v_7 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); } - let __ret: [G; OUT_679] = []; - record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_687] = []; + record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58253,23 +58895,23 @@ fn aiur_fn_679( }) } -const INPUT_SIZE_680: usize = 3; -const IN_680: usize = 3; -const OUT_680: usize = 0; -fn aiur_fn_680( - inp: [G; IN_680], +const INPUT_SIZE_688: usize = 3; +const IN_688: usize = 3; +const OUT_688: usize = 0; +fn aiur_fn_688( + inp: [G; IN_688], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_680], ExecError> { +) -> Result<[G; OUT_688], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_680] = []; - record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = []; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -58435,8 +59077,8 @@ fn aiur_fn_680( if (__v_34 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64() }); } - let __ret: [G; OUT_680] = []; - record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = []; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58446,27 +59088,27 @@ fn aiur_fn_680( }) } -const INPUT_SIZE_681: usize = 3; -const IN_681: usize = 3; -const OUT_681: usize = 0; -fn aiur_fn_681( - inp: [G; IN_681], +const INPUT_SIZE_689: usize = 3; +const IN_689: usize = 3; +const OUT_689: usize = 0; +fn aiur_fn_689( + inp: [G; IN_689], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_681], ExecError> { +) -> Result<[G; OUT_689], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_681] = []; - record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = []; + record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0]; 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_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_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]; @@ -58630,8 +59272,8 @@ fn aiur_fn_681( if (__v_35 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64() }); } - let __ret: [G; OUT_681] = []; - record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = []; + record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58641,15 +59283,15 @@ fn aiur_fn_681( }) } -const INPUT_SIZE_682: usize = 2; -const IN_682: usize = 2; -const OUT_682: usize = 0; -fn aiur_fn_682( - inp: [G; IN_682], +const INPUT_SIZE_690: usize = 2; +const IN_690: usize = 2; +const OUT_690: usize = 0; +fn aiur_fn_690( + inp: [G; IN_690], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_682], ExecError> { +) -> Result<[G; OUT_690], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58689,8 +59331,8 @@ fn aiur_fn_682( let __v_31: G = __loaded[10]; match __v_21.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_682] = []; - record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_690] = []; + record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58742,10 +59384,10 @@ fn aiur_fn_682( return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); } let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_30, __v_32, __v_19]; 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_31, __v_20]; 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 __ret: [G; OUT_682] = []; - record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_30, __v_32, __v_19]; 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_31, __v_20]; 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 __ret: [G; OUT_690] = []; + record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -58764,29 +59406,29 @@ fn aiur_fn_682( }) } -const INPUT_SIZE_683: usize = 3; -const IN_683: usize = 3; -const OUT_683: usize = 0; -fn aiur_fn_683( - inp: [G; IN_683], +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_683], ExecError> { +) -> Result<[G; OUT_691], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_683] = []; - record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + 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_682] = { let __args: [G; IN_682] = [__v_0, __v_2]; 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 __ret: [G; OUT_683] = []; - record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __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 __ret: [G; OUT_691] = []; + record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58796,15 +59438,15 @@ fn aiur_fn_683( }) } -const INPUT_SIZE_684: usize = 49; -const IN_684: usize = 49; -const OUT_684: usize = 0; -fn aiur_fn_684( - inp: [G; IN_684], +const INPUT_SIZE_692: usize = 49; +const IN_692: usize = 49; +const OUT_692: usize = 0; +fn aiur_fn_692( + inp: [G; IN_692], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_684], ExecError> { +) -> Result<[G; OUT_692], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58855,7 +59497,7 @@ fn aiur_fn_684( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__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[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_735] = { let __args: [G; IN_735] = [__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[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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; @@ -58894,14 +59536,14 @@ fn aiur_fn_684( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_49, __v_9, __v_10]; 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_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[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_679] = { let __args: [G; IN_679] = [__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[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_679] = { let __args: [G; IN_679] = [__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[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_679] = { let __args: [G; IN_679] = [__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[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_681] = { let __args: [G; IN_681] = [__v_82, __v_47, __v_48]; 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 __ret: [G; OUT_684] = []; - record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_49, __v_9, __v_10]; 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_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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_82, __v_47, __v_48]; 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 __ret: [G; OUT_692] = []; + record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -58910,15 +59552,15 @@ fn aiur_fn_684( }) } -const INPUT_SIZE_685: usize = 2; -const IN_685: usize = 2; -const OUT_685: usize = 0; -fn aiur_fn_685( - inp: [G; IN_685], +const INPUT_SIZE_693: usize = 2; +const IN_693: usize = 2; +const OUT_693: usize = 0; +fn aiur_fn_693( + inp: [G; IN_693], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_685], ExecError> { +) -> Result<[G; OUT_693], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58975,15 +59617,15 @@ fn aiur_fn_685( let __v_51: G = __loaded[49]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_685] = []; - record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_693] = []; + record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__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[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_0, __v_51]; 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 __ret: [G; OUT_685] = []; - record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__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[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_0, __v_51]; 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 __ret: [G; OUT_693] = []; + record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58993,29 +59635,29 @@ fn aiur_fn_685( }) } -const INPUT_SIZE_686: usize = 3; -const IN_686: usize = 3; -const OUT_686: usize = 0; -fn aiur_fn_686( - inp: [G; IN_686], +const INPUT_SIZE_694: usize = 3; +const IN_694: usize = 3; +const OUT_694: usize = 0; +fn aiur_fn_694( + inp: [G; IN_694], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_686], ExecError> { +) -> Result<[G; OUT_694], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_686] = []; - record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_694] = []; + record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_0, __v_2]; 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 __ret: [G; OUT_686] = []; - record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0, __v_2]; 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 __ret: [G; OUT_694] = []; + record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59025,15 +59667,15 @@ fn aiur_fn_686( }) } -const INPUT_SIZE_687: usize = 99; -const IN_687: usize = 99; -const OUT_687: usize = 0; -fn aiur_fn_687( - inp: [G; IN_687], +const INPUT_SIZE_695: usize = 99; +const IN_695: usize = 99; +const OUT_695: usize = 0; +fn aiur_fn_695( + inp: [G; IN_695], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_687], ExecError> { +) -> Result<[G; OUT_695], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59140,13 +59782,13 @@ fn aiur_fn_687( 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_1, __v_46, __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_676] = { let __args: [G; IN_676] = [__v_2, __v_48, __v_49]; 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_679] = { let __args: [G; IN_679] = [__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[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_681] = { let __args: [G; IN_681] = [__v_11, __v_59, __v_60]; 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_681] = { let __args: [G; IN_681] = [__v_12, __v_61, __v_62]; 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 __ret: [G; OUT_687] = []; - record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_1, __v_46, __v_47]; 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_684] = { let __args: [G; IN_684] = [__v_2, __v_48, __v_49]; 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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_11, __v_59, __v_60]; 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_689] = { let __args: [G; IN_689] = [__v_12, __v_61, __v_62]; 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 __ret: [G; OUT_695] = []; + record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -59161,17 +59803,17 @@ fn aiur_fn_687( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_1, __v_46, __v_47]; 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_678] = { let __args: [G; IN_678] = [__v_2, __v_48, __v_49]; 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_678] = { let __args: [G; IN_678] = [__v_3, __v_50, __v_51]; 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_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; 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_679] = { let __args: [G; IN_679] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69]; 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_679] = { let __args: [G; IN_679] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78]; 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_679] = { let __args: [G; IN_679] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; 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_681] = { let __args: [G; IN_681] = [__v_36, __v_88, __v_89]; 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_686] = { let __args: [G; IN_686] = [__v_37, __v_90, __v_91]; 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 __ret: [G; OUT_687] = []; - record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_1, __v_46, __v_47]; 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_686] = { let __args: [G; IN_686] = [__v_2, __v_48, __v_49]; 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_686] = { let __args: [G; IN_686] = [__v_3, __v_50, __v_51]; 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_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; 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_687] = { let __args: [G; IN_687] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69]; 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_687] = { let __args: [G; IN_687] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78]; 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_687] = { let __args: [G; IN_687] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; 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_689] = { let __args: [G; IN_689] = [__v_36, __v_88, __v_89]; 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_694] = { let __args: [G; IN_694] = [__v_37, __v_90, __v_91]; 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 __ret: [G; OUT_695] = []; + record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -59186,17 +59828,17 @@ fn aiur_fn_687( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_1, __v_46, __v_47]; 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_678] = { let __args: [G; IN_678] = [__v_2, __v_48, __v_49]; 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_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[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_679] = { let __args: [G; IN_679] = [__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[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_679] = { let __args: [G; IN_679] = [__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[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_679] = { let __args: [G; IN_679] = [__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[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_679] = { let __args: [G; IN_679] = [__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[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_681] = { let __args: [G; IN_681] = [__v_43, __v_95, __v_96]; 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_683] = { let __args: [G; IN_683] = [__v_44, __v_97, __v_98]; 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 __ret: [G; OUT_687] = []; - record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_1, __v_46, __v_47]; 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_686] = { let __args: [G; IN_686] = [__v_2, __v_48, __v_49]; 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_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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_43, __v_95, __v_96]; 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_691] = { let __args: [G; IN_691] = [__v_44, __v_97, __v_98]; 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 __ret: [G; OUT_695] = []; + record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -59213,15 +59855,15 @@ fn aiur_fn_687( }) } -const INPUT_SIZE_688: usize = 2; -const IN_688: usize = 2; -const OUT_688: usize = 0; -fn aiur_fn_688( - inp: [G; IN_688], +const INPUT_SIZE_696: usize = 2; +const IN_696: usize = 2; +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_688], 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]; @@ -59292,12 +59934,12 @@ fn aiur_fn_688( let __v_65: G = __loaded[63]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_688] = []; - record.function_queries[688].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 => { - 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_730] = { let __args: [G; IN_730] = [__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[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_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -59343,10 +59985,10 @@ fn aiur_fn_688( 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_687] = { let __args: [G; IN_687] = [__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[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_0, __v_65]; 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 __ret: [G; OUT_688] = []; - record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + 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_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[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_0, __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 __ret: [G; OUT_696] = []; + record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59356,15 +59998,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_697: usize = 1; +const IN_697: usize = 1; +const OUT_697: usize = 1; +fn aiur_fn_697( + inp: [G; IN_697], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_689], ExecError> { +) -> Result<[G; OUT_697], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); @@ -59377,21 +60019,21 @@ fn aiur_fn_689( 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_19] = { let __args: [G; IN_19] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_689] = [__v_8]; - record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_697] = [__v_8]; + record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_690: usize = 2; -const IN_690: usize = 2; -const OUT_690: usize = 1; -fn aiur_fn_690( - inp: [G; IN_690], +const INPUT_SIZE_698: usize = 2; +const IN_698: usize = 2; +const OUT_698: usize = 1; +fn aiur_fn_698( + inp: [G; IN_698], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_690], 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]; @@ -59407,21 +60049,21 @@ fn aiur_fn_690( 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_19] = { let __args: [G; IN_19] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_690] = [__v_10]; - record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_698] = [__v_10]; + record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_691: usize = 1; -const IN_691: usize = 1; -const OUT_691: usize = 3; -fn aiur_fn_691( - inp: [G; IN_691], +const INPUT_SIZE_699: usize = 1; +const IN_699: usize = 1; +const OUT_699: usize = 3; +fn aiur_fn_699( + inp: [G; IN_699], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_691], ExecError> { +) -> Result<[G; OUT_699], 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)? } }; @@ -59432,15 +60074,15 @@ fn aiur_fn_691( let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_3]; 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_697] = { let __args: [G; IN_697] = [__v_3]; 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 __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_691] = [__v_5, __v_10, __v_4]; - record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_699] = [__v_5, __v_10, __v_4]; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -59480,25 +60122,25 @@ fn aiur_fn_691( 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_691] = [__v_35, __v_38, __v_2]; - record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_699] = [__v_35, __v_38, __v_2]; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - 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_699] = { let __args: [G; IN_699] = [__v_2]; 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 __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_691] = { let __args: [G; IN_691] = [__v_5]; 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_699] = { let __args: [G; IN_699] = [__v_5]; 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 __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_690] = { let __args: [G; IN_690] = [__v_3, __v_6]; 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_698] = { let __args: [G; IN_698] = [__v_3, __v_6]; 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 __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __v_7]; 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_721] = { let __args: [G; IN_721] = [__v_4, __v_7]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_691] = [__v_9, __v_10, __v_8]; - record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_699] = [__v_9, __v_10, __v_8]; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59508,15 +60150,15 @@ fn aiur_fn_691( }) } -const INPUT_SIZE_692: usize = 1; -const IN_692: usize = 1; -const OUT_692: usize = 1; -fn aiur_fn_692( - inp: [G; IN_692], +const INPUT_SIZE_700: usize = 1; +const IN_700: usize = 1; +const OUT_700: usize = 1; +fn aiur_fn_700( + inp: [G; IN_700], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_692], ExecError> { +) -> Result<[G; OUT_700], 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 }; @@ -59578,7 +60220,7 @@ fn aiur_fn_692( if (__v_39 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_49.as_canonical_u64() }); } - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__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_699] = { let __args: [G; IN_699] = [__v_47]; 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 __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -59726,21 +60368,21 @@ fn aiur_fn_692( if (__v_89 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_32.as_canonical_u64() }); } - let __ret: [G; OUT_692] = [__v_51]; - record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_700] = [__v_51]; + record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_693: usize = 2; -const IN_693: usize = 2; -const OUT_693: usize = 1; -fn aiur_fn_693( - inp: [G; IN_693], +const INPUT_SIZE_701: usize = 2; +const IN_701: usize = 2; +const OUT_701: usize = 1; +fn aiur_fn_701( + inp: [G; IN_701], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_693], 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]; @@ -59751,8 +60393,8 @@ fn aiur_fn_693( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_693] = [__v_5]; - record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_701] = [__v_5]; + record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -59761,15 +60403,15 @@ fn aiur_fn_693( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_693] = [__v_6]; - record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_701] = [__v_6]; + record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0, __v_4]; 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_701] = { let __args: [G; IN_701] = [__v_0, __v_4]; 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 __v_6: G = __r_arr[0]; - let __ret: [G; OUT_693] = [__v_6]; - record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_701] = [__v_6]; + record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -59781,15 +60423,15 @@ fn aiur_fn_693( }) } -const INPUT_SIZE_694: usize = 1; -const IN_694: usize = 1; -const OUT_694: usize = 1; -fn aiur_fn_694( - inp: [G; IN_694], +const INPUT_SIZE_702: usize = 1; +const IN_702: usize = 1; +const OUT_702: usize = 1; +fn aiur_fn_702( + inp: [G; IN_702], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_694], ExecError> { +) -> Result<[G; OUT_702], 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 }; @@ -59834,21 +60476,21 @@ fn aiur_fn_694( let __v_39: G = (__v_36 + __v_38); let __v_40: G = (__v_34 + __v_39); let __v_41: G = (__v_1 + __v_40); - let __ret: [G; OUT_694] = [__v_41]; - record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_702] = [__v_41]; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_695: usize = 7; -const IN_695: usize = 7; -const OUT_695: usize = 6; -fn aiur_fn_695( - inp: [G; IN_695], +const INPUT_SIZE_703: usize = 7; +const IN_703: usize = 7; +const OUT_703: usize = 6; +fn aiur_fn_703( + inp: [G; IN_703], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_695], 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]; @@ -59863,29 +60505,29 @@ fn aiur_fn_695( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_695] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; - record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_703] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_8]; 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_702] = { let __args: [G; IN_702] = [__v_8]; 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 __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_10, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_743] = { let __args: [G; IN_743] = [__v_10, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __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_695] = { let __args: [G; IN_695] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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_703] = { let __args: [G; IN_703] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 __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_695] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_703] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59895,15 +60537,15 @@ fn aiur_fn_695( }) } -const INPUT_SIZE_696: usize = 7; -const IN_696: usize = 7; -const OUT_696: usize = 1; -fn aiur_fn_696( - inp: [G; IN_696], +const INPUT_SIZE_704: usize = 7; +const IN_704: usize = 7; +const OUT_704: usize = 1; +fn aiur_fn_704( + inp: [G; IN_704], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_696], 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]; @@ -59912,7 +60554,7 @@ fn aiur_fn_696( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_0]; 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 __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); @@ -59947,34 +60589,34 @@ fn aiur_fn_696( 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 __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_40]; 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_723] = { let __args: [G; IN_723] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_40]; 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_41: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_41, __v_0]; 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_42: G = __r_arr[0]; - let __ret: [G; OUT_696] = [__v_42]; - record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_704] = [__v_42]; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_697: usize = 4; -const IN_697: usize = 4; -const OUT_697: usize = 0; -fn aiur_fn_697( - inp: [G; IN_697], +const INPUT_SIZE_705: usize = 4; +const IN_705: usize = 4; +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_697], 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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_1]; 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_632] = { let __args: [G; IN_632] = [__v_1]; 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_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __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_703] = { let __args: [G; IN_703] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; 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 __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -59982,22 +60624,22 @@ fn aiur_fn_697( let __v_10: G = __r_arr[4]; let __v_11: G = __r_arr[5]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_697] = []; - record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -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_706: usize = 10; +const IN_706: usize = 10; +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_698], 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]; @@ -60015,8 +60657,8 @@ fn aiur_fn_698( let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_698] = []; - record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -60032,26 +60674,26 @@ fn aiur_fn_698( let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; let __v_23: G = __loaded[10]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_9]; 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_726] = { let __args: [G; IN_726] = [__v_2, __v_9]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_704] = { let __args: [G; IN_704] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 __v_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_706] = { let __args: [G; IN_706] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_9, __v_1, __v_2]; 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_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_9, __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_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_706] = { let __args: [G; IN_706] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60063,15 +60705,15 @@ 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_707: usize = 3; +const IN_707: usize = 3; +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_699], 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]; @@ -60081,17 +60723,17 @@ fn aiur_fn_699( let __v_4: G = __r_arr[1]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_3, __v_4]; 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 __ret: [G; OUT_699] = []; - record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_3, __v_3, __v_4]; 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_707] = []; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_2]; 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_700] = { let __args: [G; IN_700] = [__v_2]; 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 __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_3, __v_3, __v_4, __v_5]; 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_699] = []; - record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_3, __v_3, __v_4, __v_5]; 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)); return Ok(__ret); }, _ => { @@ -60101,63 +60743,63 @@ fn aiur_fn_699( }) } -const INPUT_SIZE_700: usize = 2; -const IN_700: usize = 2; -const OUT_700: usize = 0; -fn aiur_fn_700( - inp: [G; IN_700], +const INPUT_SIZE_708: usize = 2; +const IN_708: usize = 2; +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_700], 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]; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_0]; 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_700] = { let __args: [G; IN_700] = [__v_0]; 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 __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_1, __v_2]; 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_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !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 __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() }); } - let __ret: [G; OUT_700] = []; - record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_708] = []; + record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_701: usize = 3; -const IN_701: usize = 3; -const OUT_701: usize = 0; -fn aiur_fn_701( - inp: [G; IN_701], +const INPUT_SIZE_709: usize = 3; +const IN_709: usize = 3; +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_701], 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_692] = { let __args: [G; IN_692] = [__v_0]; 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_700] = { let __args: [G; IN_700] = [__v_0]; 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 __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_4, __v_5]; 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 __ret: [G; OUT_701] = []; - record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_4, __v_4, __v_5]; 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_709] = []; + record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_2]; 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_700] = { let __args: [G; IN_700] = [__v_2]; 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 __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_4, __v_4, __v_5, __v_6]; 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_701] = []; - record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4, __v_4, __v_5, __v_6]; 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_709] = []; + record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60167,15 +60809,15 @@ fn aiur_fn_701( }) } -const INPUT_SIZE_702: usize = 55; -const IN_702: usize = 55; -const OUT_702: usize = 0; -fn aiur_fn_702( - inp: [G; IN_702], +const INPUT_SIZE_710: usize = 55; +const IN_710: usize = 55; +const OUT_710: usize = 0; +fn aiur_fn_710( + inp: [G; IN_710], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_702], 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]; @@ -60289,13 +60931,13 @@ fn aiur_fn_702( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_56, __v_2, __v_3]; 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_676] = { let __args: [G; IN_676] = [__v_57, __v_4, __v_5]; 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_679] = { let __args: [G; IN_679] = [__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[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_681] = { let __args: [G; IN_681] = [__v_66, __v_15, __v_16]; 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_681] = { let __args: [G; IN_681] = [__v_67, __v_17, __v_18]; 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 __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_56, __v_2, __v_3]; 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_684] = { let __args: [G; IN_684] = [__v_57, __v_4, __v_5]; 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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_66, __v_15, __v_16]; 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_689] = { let __args: [G; IN_689] = [__v_67, __v_17, __v_18]; 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 __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60310,17 +60952,17 @@ fn aiur_fn_702( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_56, __v_2, __v_3]; 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_678] = { let __args: [G; IN_678] = [__v_57, __v_4, __v_5]; 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_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[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_679] = { let __args: [G; IN_679] = [__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[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_679] = { let __args: [G; IN_679] = [__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[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_679] = { let __args: [G; IN_679] = [__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[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_679] = { let __args: [G; IN_679] = [__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[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_681] = { let __args: [G; IN_681] = [__v_98, __v_51, __v_52]; 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_683] = { let __args: [G; IN_683] = [__v_99, __v_53, __v_54]; 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 __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_56, __v_2, __v_3]; 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_686] = { let __args: [G; IN_686] = [__v_57, __v_4, __v_5]; 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_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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_98, __v_51, __v_52]; 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_691] = { let __args: [G; IN_691] = [__v_99, __v_53, __v_54]; 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 __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60335,11 +60977,11 @@ fn aiur_fn_702( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_56, __v_2, __v_3]; 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_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[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_681] = { let __args: [G; IN_681] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_56, __v_2, __v_3]; 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_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[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_689] = { let __args: [G; IN_689] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60354,11 +60996,11 @@ fn aiur_fn_702( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_56, __v_2, __v_3]; 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_679] = { let __args: [G; IN_679] = [__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[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_681] = { let __args: [G; IN_681] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_56, __v_2, __v_3]; 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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60373,11 +61015,11 @@ fn aiur_fn_702( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__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[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_679] = { let __args: [G; IN_679] = [__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[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_72, __v_20, __v_21]; 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 __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_20, __v_21]; 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 __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60392,10 +61034,10 @@ fn aiur_fn_702( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60410,10 +61052,10 @@ fn aiur_fn_702( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60428,10 +61070,10 @@ fn aiur_fn_702( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60444,9 +61086,9 @@ fn aiur_fn_702( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_56, __v_2]; 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 __ret: [G; OUT_702] = []; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_56, __v_2]; 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_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60463,15 +61105,15 @@ fn aiur_fn_702( }) } -const INPUT_SIZE_703: usize = 4; -const IN_703: usize = 4; -const OUT_703: usize = 0; -fn aiur_fn_703( - inp: [G; IN_703], +const INPUT_SIZE_711: usize = 4; +const IN_711: usize = 4; +const OUT_711: usize = 0; +fn aiur_fn_711( + inp: [G; IN_711], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_703], 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]; @@ -60482,21 +61124,21 @@ fn aiur_fn_703( if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); } - let __ret: [G; OUT_703] = []; - record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_711] = []; + record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_704: usize = 32; -const IN_704: usize = 32; -const OUT_704: usize = 0; -fn aiur_fn_704( - inp: [G; IN_704], +const INPUT_SIZE_712: usize = 32; +const IN_712: usize = 32; +const OUT_712: usize = 0; +fn aiur_fn_712( + inp: [G; IN_712], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_704], 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]; @@ -60530,7 +61172,7 @@ fn aiur_fn_704( let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[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_681] = { let __args: [G; IN_681] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; @@ -60589,33 +61231,33 @@ fn aiur_fn_704( let __v_87: G = __r_arr[55]; match __v_32.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_33, __v_34, __v_35, __v_36]; 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_711] = { let __args: [G; IN_711] = [__v_33, __v_34, __v_35, __v_36]; 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 __ret: [G; OUT_712] = []; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_33, __v_34, __v_35]; 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_704] = []; - record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_33, __v_34, __v_35]; 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_712] = []; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_33, __v_34, __v_35]; 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_704] = []; - record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_33, __v_34, __v_35]; 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 __ret: [G; OUT_712] = []; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; 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_704] = []; - record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; 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 __ret: [G; OUT_712] = []; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_33, __v_34]; 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_708] = { let __args: [G; IN_708] = [__v_33, __v_34]; 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_712] = []; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60625,15 +61267,15 @@ fn aiur_fn_704( }) } -const INPUT_SIZE_705: usize = 32; -const IN_705: usize = 32; -const OUT_705: usize = 0; -fn aiur_fn_705( - inp: [G; IN_705], +const INPUT_SIZE_713: usize = 32; +const IN_713: usize = 32; +const OUT_713: usize = 0; +fn aiur_fn_713( + inp: [G; IN_713], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_705], 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]; @@ -60674,7 +61316,7 @@ fn aiur_fn_705( let __v_35: G = G::from_u64(0); let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_32, __v_34, __v_35]; 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_36: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_33, __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_726] = { let __args: [G; IN_726] = [__v_33, __v_36]; 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_37: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_38: G = __loaded[0]; @@ -60688,28 +61330,28 @@ fn aiur_fn_705( let __v_46: G = __loaded[8]; let __v_47: G = __loaded[9]; let __v_48: G = __loaded[10]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_36, __v_33, __v_34]; 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_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_36, __v_33, __v_34]; 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_713] = []; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_706: usize = 1; -const IN_706: usize = 1; -const OUT_706: usize = 0; -fn aiur_fn_706( - inp: [G; IN_706], +const INPUT_SIZE_714: usize = 1; +const IN_714: usize = 1; +const OUT_714: usize = 0; +fn aiur_fn_714( + inp: [G; IN_714], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_706], ExecError> { +) -> Result<[G; OUT_714], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_714] = []; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60795,24 +61437,24 @@ fn aiur_fn_706( if (__v_7 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_65.as_canonical_u64() }); } - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_2]; 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_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_2]; 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 __ret: [G; OUT_714] = []; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_707: usize = 0; -const IN_707: usize = 0; -const OUT_707: usize = 0; -fn aiur_fn_707( - inp: [G; IN_707], +const INPUT_SIZE_715: usize = 0; +const IN_715: usize = 0; +const OUT_715: usize = 0; +fn aiur_fn_715( + inp: [G; IN_715], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_707], ExecError> { +) -> Result<[G; OUT_715], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(0); @@ -60948,44 +61590,44 @@ fn aiur_fn_707( if (__v_66 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64() }); } - let __ret: [G; OUT_707] = []; - record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_715] = []; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_708: usize = 0; -const IN_708: usize = 0; -const OUT_708: usize = 0; -fn aiur_fn_708( - inp: [G; IN_708], +const INPUT_SIZE_716: usize = 0; +const IN_716: usize = 0; +const OUT_716: usize = 0; +fn aiur_fn_716( + inp: [G; IN_716], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_708], ExecError> { +) -> Result<[G; OUT_716], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = []; 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_715] = { let __args: [G; IN_715] = []; 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 __ret: [G; OUT_716] = []; + record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_709: usize = 1; -const IN_709: usize = 1; -const OUT_709: usize = 0; -fn aiur_fn_709( - inp: [G; IN_709], +const INPUT_SIZE_717: usize = 1; +const IN_717: usize = 1; +const OUT_717: usize = 0; +fn aiur_fn_717( + inp: [G; IN_717], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_709], ExecError> { +) -> Result<[G; OUT_717], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_709] = []; - record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_717] = []; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61230,24 +61872,24 @@ fn aiur_fn_709( if (__v_97 != __v_129) { return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_129.as_canonical_u64() }); } - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !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 __ret: [G; OUT_709] = []; - record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + 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 __ret: [G; OUT_717] = []; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -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_718: usize = 2; +const IN_718: usize = 2; +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_710], ExecError> { +) -> Result<[G; OUT_718], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -61262,17 +61904,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_718] = [__v_9]; + record.function_queries[718].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_718] = { let __args: [G; IN_718] = [__v_4, __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_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_718] = [__v_7]; + record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61282,15 +61924,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_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_711], ExecError> { +) -> Result<[G; OUT_719], 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 }; @@ -61314,12 +61956,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_719] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + record.function_queries[719].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_719] = { let __args: [G; IN_719] = [__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 = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -61337,8 +61979,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_719] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61348,15 +61990,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_720: usize = 1; +const IN_720: usize = 1; +const OUT_720: usize = 8; +fn aiur_fn_720( + inp: [G; IN_720], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_712], ExecError> { +) -> Result<[G; OUT_720], 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 }; @@ -61373,12 +62015,12 @@ fn aiur_fn_712( 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_712] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_720] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_3]; 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_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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -61396,8 +62038,8 @@ fn aiur_fn_712( 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_712] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_720] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61407,15 +62049,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_721: usize = 2; +const IN_721: usize = 2; +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_713], 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]; @@ -61425,17 +62067,17 @@ fn aiur_fn_713( let __v_4: G = __loaded[2]; 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_721] = [__v_1]; + record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __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_721] = { let __args: [G; IN_721] = [__v_4, __v_1]; 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_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_713] = [__v_7]; - record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_721] = [__v_7]; + record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61445,15 +62087,15 @@ fn aiur_fn_713( }) } -const INPUT_SIZE_714: usize = 2; -const IN_714: usize = 2; -const OUT_714: usize = 1; -fn aiur_fn_714( - inp: [G; IN_714], +const INPUT_SIZE_722: usize = 2; +const IN_722: usize = 2; +const OUT_722: usize = 1; +fn aiur_fn_722( + inp: [G; IN_722], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_714], 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]; @@ -61465,17 +62107,17 @@ fn aiur_fn_714( let __v_6: G = __loaded[4]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_714] = [__v_1]; - record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_722] = [__v_1]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_6, __v_1]; 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_722] = { let __args: [G; IN_722] = [__v_6, __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_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 5] = [__v_7, __v_3, __v_4, __v_5, __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_714] = [__v_9]; - record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_722] = [__v_9]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61485,15 +62127,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_723: usize = 8; +const IN_723: usize = 8; +const OUT_723: usize = 1; +fn aiur_fn_723( + inp: [G; IN_723], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_715], ExecError> { +) -> Result<[G; OUT_723], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -61505,8 +62147,8 @@ 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_723] = [__v_7]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -61527,25 +62169,25 @@ 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_723] = { let __args: [G; IN_723] = [__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[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_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_723] = [__v_21]; + record.function_queries[723].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_715] = [__v_4]; - record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_723] = [__v_4]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); 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_723] = { let __args: [G; IN_723] = [__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[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_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_723] = [__v_22]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -61559,37 +62201,37 @@ 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_724: usize = 1; +const IN_724: usize = 1; +const OUT_724: usize = 1; +fn aiur_fn_724( + inp: [G; IN_724], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_716], ExecError> { +) -> Result<[G; OUT_724], 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_737] = { let __args: [G; IN_737] = [__v_0, __v_3]; 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_745] = { let __args: [G; IN_745] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; let __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_724] = [__v_4]; + record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_717: usize = 1; -const IN_717: usize = 1; -const OUT_717: usize = 8; -fn aiur_fn_717( - inp: [G; IN_717], +const INPUT_SIZE_725: usize = 1; +const IN_725: usize = 1; +const OUT_725: usize = 8; +fn aiur_fn_725( + inp: [G; IN_725], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_717], ExecError> { +) -> Result<[G; OUT_725], 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 }; @@ -61639,12 +62281,12 @@ fn aiur_fn_717( 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_717] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; - record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_725] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_36]; 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_725] = { let __args: [G; IN_725] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -61662,8 +62304,8 @@ fn aiur_fn_717( 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_717] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; - record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_725] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61673,19 +62315,19 @@ fn aiur_fn_717( }) } -const INPUT_SIZE_718: usize = 2; -const IN_718: usize = 2; -const OUT_718: usize = 1; -fn aiur_fn_718( - inp: [G; IN_718], +const INPUT_SIZE_726: usize = 2; +const IN_726: usize = 2; +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_718], 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]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_1]; 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_741] = { let __args: [G; IN_741] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __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]; @@ -61693,8 +62335,8 @@ fn aiur_fn_718( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_718] = [__v_4]; - record.function_queries[718].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); }, _ => { @@ -61704,15 +62346,15 @@ fn aiur_fn_718( }) } -const INPUT_SIZE_719: usize = 9; -const IN_719: usize = 9; -const OUT_719: usize = 1; -fn aiur_fn_719( - inp: [G; IN_719], +const INPUT_SIZE_727: usize = 9; +const IN_727: usize = 9; +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_719], 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]; @@ -61733,8 +62375,8 @@ fn aiur_fn_719( let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_719] = [__v_10]; - record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_727] = [__v_10]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -61747,10 +62389,10 @@ fn aiur_fn_719( let __v_18: G = __r_arr[5]; let __v_19: G = __r_arr[6]; let __v_20: G = __r_arr[7]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_11, __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[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_727] = { let __args: [G; IN_727] = [__v_11, __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[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_21: G = __r_arr[0]; - let __ret: [G; OUT_719] = [__v_21]; - record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_727] = [__v_21]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61765,15 +62407,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_728: usize = 1; +const IN_728: usize = 1; +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_720], ExecError> { +) -> Result<[G; OUT_728], 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 }; @@ -61790,17 +62432,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_728] = [__v_11]; + record.function_queries[728].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_728] = { let __args: [G; IN_728] = [__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 __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_728] = [__v_13]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61810,15 +62452,15 @@ fn aiur_fn_720( }) } -const INPUT_SIZE_721: usize = 7; -const IN_721: usize = 7; -const OUT_721: usize = 1; -fn aiur_fn_721( - inp: [G; IN_721], +const INPUT_SIZE_729: usize = 7; +const IN_729: usize = 7; +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_721], 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]; @@ -61846,25 +62488,25 @@ fn aiur_fn_721( let __v_19: 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_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __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_729] = { let __args: [G; IN_729] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_20: G = __r_arr[0]; - let __ret: [G; OUT_721] = [__v_20]; - record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_729] = [__v_20]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_20: G = (__v_0 - __v_3); match __v_20.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_721] = [__v_4]; - record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_729] = [__v_4]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_729] = { let __args: [G; IN_729] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_21: G = __r_arr[0]; - let __ret: [G; OUT_721] = [__v_21]; - record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_729] = [__v_21]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -61878,15 +62520,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_730: usize = 9; +const IN_730: usize = 9; +const OUT_730: usize = 45; +fn aiur_fn_730( + inp: [G; IN_730], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_722], 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]; @@ -61951,8 +62593,8 @@ 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_730] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -61965,7 +62607,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_730] = { let __args: [G; IN_730] = [__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[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_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -62011,8 +62653,8 @@ 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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62027,15 +62669,15 @@ fn aiur_fn_722( }) } -const INPUT_SIZE_723: usize = 2; -const IN_723: usize = 2; -const OUT_723: usize = 1; -fn aiur_fn_723( - inp: [G; IN_723], +const INPUT_SIZE_731: usize = 2; +const IN_731: usize = 2; +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_723], 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]; @@ -62048,17 +62690,17 @@ fn aiur_fn_723( let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_723] = [__v_1]; - record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_731] = [__v_1]; + record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_7, __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_731] = { let __args: [G; IN_731] = [__v_7, __v_1]; 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_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 6] = [__v_8, __v_3, __v_4, __v_5, __v_6, __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_723] = [__v_10]; - record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_731] = [__v_10]; + record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62068,15 +62710,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_732: usize = 1; +const IN_732: usize = 1; +const OUT_732: usize = 8; +fn aiur_fn_732( + inp: [G; IN_732], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_724], ExecError> { +) -> Result<[G; OUT_732], 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 }; @@ -62137,12 +62779,12 @@ fn aiur_fn_724( 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_724] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; - record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_732] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_47]; 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_732] = { let __args: [G; IN_732] = [__v_47]; 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_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -62160,8 +62802,8 @@ fn aiur_fn_724( 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_724] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; - record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_732] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62171,15 +62813,15 @@ fn aiur_fn_724( }) } -const INPUT_SIZE_725: usize = 1; -const IN_725: usize = 1; -const OUT_725: usize = 8; -fn aiur_fn_725( - inp: [G; IN_725], +const INPUT_SIZE_733: usize = 1; +const IN_733: usize = 1; +const OUT_733: usize = 8; +fn aiur_fn_733( + inp: [G; IN_733], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_725], ExecError> { +) -> Result<[G; OUT_733], 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 }; @@ -62204,12 +62846,12 @@ fn aiur_fn_725( 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_725] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_733] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_11]; 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_733] = { let __args: [G; IN_733] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -62227,8 +62869,8 @@ fn aiur_fn_725( 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_725] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; - record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_733] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62238,15 +62880,15 @@ fn aiur_fn_725( }) } -const INPUT_SIZE_726: usize = 2; -const IN_726: usize = 2; -const OUT_726: usize = 1; -fn aiur_fn_726( - inp: [G; IN_726], +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_726], 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]; @@ -62257,17 +62899,17 @@ fn aiur_fn_726( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_726] = [__v_1]; - record.function_queries[726].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_6: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_1]; 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_734] = { let __args: [G; IN_734] = [__v_5, __v_1]; 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 __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_726] = [__v_8]; - record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_734] = [__v_8]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62277,15 +62919,15 @@ fn aiur_fn_726( }) } -const INPUT_SIZE_727: usize = 9; -const IN_727: usize = 9; -const OUT_727: usize = 34; -fn aiur_fn_727( - inp: [G; IN_727], +const INPUT_SIZE_735: usize = 9; +const IN_735: usize = 9; +const OUT_735: usize = 34; +fn aiur_fn_735( + inp: [G; IN_735], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_727], 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]; @@ -62339,8 +62981,8 @@ fn aiur_fn_727( let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_727] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_735] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -62353,7 +62995,7 @@ fn aiur_fn_727( 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_727] = { let __args: [G; IN_727] = [__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[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_735] = { let __args: [G; IN_735] = [__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[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_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -62388,8 +63030,8 @@ fn aiur_fn_727( 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_727] = [__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[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_735] = [__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[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62404,15 +63046,15 @@ fn aiur_fn_727( }) } -const INPUT_SIZE_728: usize = 1; -const IN_728: usize = 1; -const OUT_728: usize = 1; -fn aiur_fn_728( - inp: [G; IN_728], +const INPUT_SIZE_736: usize = 1; +const IN_736: usize = 1; +const OUT_736: usize = 1; +fn aiur_fn_736( + inp: [G; IN_736], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_728], ExecError> { +) -> Result<[G; OUT_736], 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 }; @@ -62422,14 +63064,14 @@ fn aiur_fn_728( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_728] = [__v_4]; - record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_736] = [__v_4]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_728] = [__v_4]; - record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_736] = [__v_4]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62439,19 +63081,19 @@ fn aiur_fn_728( }) } -const INPUT_SIZE_729: usize = 2; -const IN_729: usize = 2; -const OUT_729: usize = 3; -fn aiur_fn_729( - inp: [G; IN_729], +const INPUT_SIZE_737: usize = 2; +const IN_737: usize = 2; +const OUT_737: usize = 3; +fn aiur_fn_737( + inp: [G; IN_737], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_729], 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]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -62461,8 +63103,8 @@ fn aiur_fn_729( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_729] = [__v_4, __v_5, __v_6]; - record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_4, __v_5, __v_6]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62472,15 +63114,15 @@ fn aiur_fn_729( }) } -const INPUT_SIZE_730: usize = 2; -const IN_730: usize = 2; -const OUT_730: usize = 1; -fn aiur_fn_730( - inp: [G; IN_730], +const INPUT_SIZE_738: usize = 2; +const IN_738: usize = 2; +const OUT_738: usize = 1; +fn aiur_fn_738( + inp: [G; IN_738], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_730], ExecError> { +) -> Result<[G; OUT_738], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62489,8 +63131,8 @@ fn aiur_fn_730( 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_730] = [__v_4]; - record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_738] = [__v_4]; + record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62503,11 +63145,11 @@ fn aiur_fn_730( 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_730] = { let __args: [G; IN_730] = [__v_4, __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_738] = { let __args: [G; IN_738] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __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_730] = [__v_9]; - record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_738] = [__v_9]; + record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62519,15 +63161,15 @@ fn aiur_fn_730( }) } -const INPUT_SIZE_731: usize = 1; -const IN_731: usize = 1; -const OUT_731: usize = 1; -fn aiur_fn_731( - inp: [G; IN_731], +const INPUT_SIZE_739: usize = 1; +const IN_739: usize = 1; +const OUT_739: usize = 1; +fn aiur_fn_739( + inp: [G; IN_739], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_731], ExecError> { +) -> Result<[G; OUT_739], 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 }; @@ -62570,17 +63212,17 @@ fn aiur_fn_731( match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_37]; - record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_739] = [__v_37]; + record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_36]; 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_739] = { let __args: [G; IN_739] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_37 + __v_38); - let __ret: [G; OUT_731] = [__v_39]; - record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_739] = [__v_39]; + record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62590,15 +63232,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_740: usize = 1; +const IN_740: usize = 1; +const OUT_740: usize = 1; +fn aiur_fn_740( + inp: [G; IN_740], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_732], ExecError> { +) -> Result<[G; OUT_740], 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 }; @@ -62611,17 +63253,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_740] = [__v_7]; + record.function_queries[740].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_740] = { let __args: [G; IN_740] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __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_740] = [__v_9]; + record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62631,28 +63273,28 @@ 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_741: usize = 2; +const IN_741: usize = 2; +const OUT_741: usize = 1; +fn aiur_fn_741( + inp: [G; IN_741], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_733], ExecError> { +) -> Result<[G; OUT_741], 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_733] = [__v_0]; - record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_741] = [__v_0]; + record.function_queries[741].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_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_741] = { let __args: [G; IN_741] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __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]; @@ -62660,8 +63302,8 @@ fn aiur_fn_733( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_733] = [__v_7]; - record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_741] = [__v_7]; + record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62673,15 +63315,15 @@ fn aiur_fn_733( }) } -const INPUT_SIZE_734: usize = 1; -const IN_734: usize = 1; -const OUT_734: usize = 1; -fn aiur_fn_734( - inp: [G; IN_734], +const INPUT_SIZE_742: usize = 1; +const IN_742: usize = 1; +const OUT_742: usize = 1; +fn aiur_fn_742( + inp: [G; IN_742], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_734], ExecError> { +) -> Result<[G; OUT_742], 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 }; @@ -62693,17 +63335,17 @@ fn aiur_fn_734( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_734] = [__v_6]; - record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_742] = [__v_6]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; 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_742] = { let __args: [G; IN_742] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __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_734] = [__v_8]; - record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_742] = [__v_8]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62713,15 +63355,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_743: usize = 8; +const IN_743: usize = 8; +const OUT_743: usize = 6; +fn aiur_fn_743( + inp: [G; IN_743], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_735], ExecError> { +) -> Result<[G; OUT_743], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62731,7 +63373,7 @@ fn aiur_fn_735( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__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[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -62742,8 +63384,8 @@ fn aiur_fn_735( 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_735] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; - record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_743] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62753,15 +63395,15 @@ fn aiur_fn_735( }) } -const INPUT_SIZE_736: usize = 9; -const IN_736: usize = 9; -const OUT_736: usize = 1; -fn aiur_fn_736( - inp: [G; IN_736], +const INPUT_SIZE_744: usize = 9; +const IN_744: usize = 9; +const OUT_744: usize = 1; +fn aiur_fn_744( + inp: [G; IN_744], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_736], ExecError> { +) -> Result<[G; OUT_744], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62790,17 +63432,17 @@ fn aiur_fn_736( 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_736] = [__v_23]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_744] = [__v_23]; + record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__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[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_744] = { let __args: [G; IN_744] = [__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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __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_736] = [__v_21]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_744] = [__v_21]; + record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62810,15 +63452,15 @@ fn aiur_fn_736( }) } -const INPUT_SIZE_737: usize = 2; -const IN_737: usize = 2; -const OUT_737: usize = 1; -fn aiur_fn_737( - inp: [G; IN_737], +const INPUT_SIZE_745: usize = 2; +const IN_745: usize = 2; +const OUT_745: usize = 1; +fn aiur_fn_745( + inp: [G; IN_745], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_737], ExecError> { +) -> Result<[G; OUT_745], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62828,17 +63470,17 @@ fn aiur_fn_737( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_737] = [__v_1]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_745] = [__v_1]; + record.function_queries[745].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_737] = { let __args: [G; IN_737] = [__v_4, __v_6]; 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_745] = { let __args: [G; IN_745] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_737] = [__v_7]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_745] = [__v_7]; + record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62848,28 +63490,28 @@ fn aiur_fn_737( }) } -const INPUT_SIZE_738: usize = 2; -const IN_738: usize = 2; -const OUT_738: usize = 1; -fn aiur_fn_738( - inp: [G; IN_738], +const INPUT_SIZE_746: usize = 2; +const IN_746: usize = 2; +const OUT_746: usize = 1; +fn aiur_fn_746( + inp: [G; IN_746], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_738], ExecError> { +) -> Result<[G; OUT_746], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_738] = [__v_0]; - record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_746] = [__v_0]; + record.function_queries[746].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_738] = { let __args: [G; IN_738] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -62879,8 +63521,8 @@ fn aiur_fn_738( let __v_9: G = __loaded[4]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_738] = [__v_9]; - record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_746] = [__v_9]; + record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62892,15 +63534,15 @@ fn aiur_fn_738( }) } -const INPUT_SIZE_739: usize = 8; -const IN_739: usize = 8; -const OUT_739: usize = 6; -fn aiur_fn_739( - inp: [G; IN_739], +const INPUT_SIZE_747: usize = 8; +const IN_747: usize = 8; +const OUT_747: usize = 6; +fn aiur_fn_747( + inp: [G; IN_747], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_739], ExecError> { +) -> Result<[G; OUT_747], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62920,8 +63562,8 @@ fn aiur_fn_739( 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_739] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; - record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_747] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -62942,22 +63584,22 @@ fn aiur_fn_739( 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_739] = { let __args: [G; IN_739] = [__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[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; let __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_740] = { let __args: [G; IN_740] = [__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[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__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[748].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; let __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_739] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; - record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_747] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62967,27 +63609,27 @@ fn aiur_fn_739( 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_739] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; - record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_747] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__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[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; let __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_740] = { let __args: [G; IN_740] = [__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[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__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[748].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; let __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_739] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_747] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63001,15 +63643,15 @@ fn aiur_fn_739( }) } -const INPUT_SIZE_740: usize = 15; -const IN_740: usize = 15; -const OUT_740: usize = 6; -fn aiur_fn_740( - inp: [G; IN_740], +const INPUT_SIZE_748: usize = 15; +const IN_748: usize = 15; +const OUT_748: usize = 6; +fn aiur_fn_748( + inp: [G; IN_748], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_740], ExecError> { +) -> Result<[G; OUT_748], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63028,38 +63670,38 @@ fn aiur_fn_740( let __v_14: G = inp[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_2, __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[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_2, __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[749].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; let __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_740] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; - record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_748] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + record.function_queries[748].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_740] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; - record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_748] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_741: usize = 14; -const IN_741: usize = 14; -const OUT_741: usize = 6; -fn aiur_fn_741( - inp: [G; IN_741], +const INPUT_SIZE_749: usize = 14; +const IN_749: usize = 14; +const OUT_749: usize = 6; +fn aiur_fn_749( + inp: [G; IN_749], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_741], ExecError> { +) -> Result<[G; OUT_749], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63099,8 +63741,8 @@ fn aiur_fn_741( 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_741] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63124,8 +63766,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63153,8 +63795,8 @@ fn aiur_fn_741( 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_741] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63178,8 +63820,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63187,8 +63829,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63198,8 +63840,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63227,8 +63869,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63236,8 +63878,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63247,8 +63889,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63260,8 +63902,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63271,8 +63913,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63304,8 +63946,8 @@ fn aiur_fn_741( 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_741] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63329,8 +63971,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63338,8 +63980,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63349,8 +63991,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63378,8 +64020,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63387,8 +64029,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63398,8 +64040,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63411,8 +64053,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63422,8 +64064,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63453,8 +64095,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63482,8 +64124,8 @@ fn aiur_fn_741( 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_741] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63507,8 +64149,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63516,8 +64158,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63527,8 +64169,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63556,8 +64198,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63565,8 +64207,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63576,8 +64218,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63589,8 +64231,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63600,8 +64242,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63633,8 +64275,8 @@ fn aiur_fn_741( 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_741] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63658,8 +64300,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63667,8 +64309,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63678,8 +64320,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63707,8 +64349,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63716,8 +64358,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63727,8 +64369,8 @@ fn aiur_fn_741( 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_741] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63740,8 +64382,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63751,8 +64393,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63786,8 +64428,8 @@ fn aiur_fn_741( 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_741] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63811,8 +64453,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63820,8 +64462,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63831,8 +64473,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63860,8 +64502,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63869,8 +64511,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63880,8 +64522,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63893,8 +64535,8 @@ fn aiur_fn_741( 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_741] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63904,8 +64546,8 @@ fn aiur_fn_741( 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_741] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63937,8 +64579,8 @@ fn aiur_fn_741( 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_741] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63962,8 +64604,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63971,8 +64613,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63982,8 +64624,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64011,8 +64653,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64020,8 +64662,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64031,8 +64673,8 @@ fn aiur_fn_741( 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_741] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64044,8 +64686,8 @@ fn aiur_fn_741( 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_741] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64055,8 +64697,8 @@ fn aiur_fn_741( 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_741] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -67782,6 +68424,46 @@ pub(crate) fn execute_generated( let __out = aiur_fn_741(__inp, record, io_buffer, false)?; return Ok(__out.to_vec()); }, + 742u64 => { + let __inp: [G; IN_742] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_742(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 743u64 => { + let __inp: [G; IN_743] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_743(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 744u64 => { + let __inp: [G; IN_744] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_744(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 745u64 => { + let __inp: [G; IN_745] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_745(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 746u64 => { + let __inp: [G; IN_746] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_746(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 747u64 => { + let __inp: [G; IN_747] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_747(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 748u64 => { + let __inp: [G; IN_748] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_748(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 749u64 => { + let __inp: [G; IN_749] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_749(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, From 2f2a86f66b70133d71e262a1cd28628398600168 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Sat, 4 Jul 2026 11:29:44 -0700 Subject: [PATCH 5/5] IxVM: port Inductive flag-drop + evaporated-aux aliasing to Aiur kernel Port of the two Rust kernel fixes on this branch: - Ixon.Inductive drops recr/refl/nested (9 -> 6 fields); KConstantInfo.Induct drops is_rec/is_reflexive/nested (10 -> 7). is_rec is computed on demand (computed_is_rec_ind), nested detection is structural (member_has_nested / ind_has_nested over detect_nested_in_orig), is_aux_inductive is rewritten member-scoped without the declared nested count. Serialization packs one bool; reveal-proof Indc masks renumber to 6 fields; all 88 primitive addresses re-pinned. - collectDependencies (Ix/Common.lean) now closes over a declaration's full recursor family (sibling .rec + nested-aux rec_N, which cross-reference in rule RHSs) plus each rule ctor's owning external recursor (List.rec). Without these the per-name compile either failed (MissingConstant AuxDedup1.C.rec from A.rec_1's block) or silently skipped the evaporated-aux alias (target_ok probe misses List.rec), compiling M.rec_2 in original form, which the kernel rejects. AuxDedup1/2/Mixed fixtures from Tests/Ix/Compile/Mutual.lean join kernelCheckEntries; the four evaporated rec_N entries pin the identical 3_073_003 FFT cost (their claims are byte-exact List.rec: lake exe ix check --interp bytecode _private...AuxDedupMixed.M.rec_2). All stdlib pins re-measured via lake test -- --ignored ixvm (flag drop shrinks serialized inductives, e.g. HEq 1_713_377 -> 1_696_277). --- Ix/Common.lean | 34 + Ix/IxVM/Convert.lean | 4 +- Ix/IxVM/Ingress.lean | 10 +- Ix/IxVM/Ixon.lean | 4 +- Ix/IxVM/IxonDeserialize.lean | 15 +- Ix/IxVM/IxonSerialize.lean | 12 +- Ix/IxVM/Kernel/CanonicalCheck.lean | 44 +- Ix/IxVM/Kernel/Check.lean | 21 +- Ix/IxVM/Kernel/Claim.lean | 34 +- Ix/IxVM/Kernel/DefEq.lean | 49 +- Ix/IxVM/Kernel/Inductive.lean | 143 +- Ix/IxVM/Kernel/Infer.lean | 8 +- Ix/IxVM/Kernel/Primitive.lean | 704 +- Ix/IxVM/Kernel/Whnf.lean | 8 +- Ix/IxVM/KernelTypes.lean | 7 +- Tests/Ix/IxVM.lean | 102 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 13777 +++++++++++++------------ 17 files changed, 7531 insertions(+), 7445 deletions(-) diff --git a/Ix/Common.lean b/Ix/Common.lean index ea202220..c2756fe7 100644 --- a/Ix/Common.lean +++ b/Ix/Common.lean @@ -328,6 +328,40 @@ private partial def collectDependenciesAux (const : Lean.ConstantInfo) goExpr consts acc val.value | .recInfo val => let acc ← collectNames val.all acc + -- The compiler processes a declaration's recursors as one block, and + -- they cross-reference in rule RHSs (`A.rec`'s rule calls `A.rec_1`, + -- `A.rec_2`'s calls `C.rec`), so the closure needs every sibling: + -- `.rec` per block inductive plus the nested-aux `.rec_N`. + let siblings := val.all.filterMap fun ind => + let n := Lean.mkRecName ind + if consts.contains n then some n else none + let auxSiblings : List Lean.Name := Id.run do + let mut out := [] + let mut i := 1 + repeat + match val.all.head? with + | none => break + | some base => + let n := Lean.Name.mkStr base s!"rec_{i}" + if consts.contains n then + out := n :: out + i := i + 1 + else break + return out + let acc ← collectNames (siblings ++ auxSiblings) acc + -- A nested-aux recursor's rules recurse via the external container's + -- ctors; its evaporated form aliases that container's recursor + -- (`List.rec`), which no collected expr mentions — pull it via each + -- rule ctor's owning inductive. + let extRecs := val.rules.filterMap fun rule => + match consts.find? rule.ctor with + | some (.ctorInfo cv) => + if val.all.contains cv.induct then none + else + let n := Lean.mkRecName cv.induct + if consts.contains n then some n else none + | _ => none + let acc ← collectNames extRecs acc let acc ← goExpr consts acc val.type val.rules.foldlM (init := acc) fun acc rule => goExpr consts acc rule.rhs where diff --git a/Ix/IxVM/Convert.lean b/Ix/IxVM/Convert.lean index 36a23744..39568923 100644 --- a/Ix/IxVM/Convert.lean +++ b/Ix/IxVM/Convert.lean @@ -314,11 +314,11 @@ def convert := ⟦ match ctx { ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => match ind { - Inductive.Mk(is_rec, is_refl, is_unsafe, lvls, params, indices, nested, typ, _) => + Inductive.Mk(is_unsafe, lvls, params, indices, typ, _) => let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); KConstantInfo.Induct( flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices), - ctor_idxs, is_rec, is_refl, is_unsafe, flatten_u64(nested), block_addr), + ctor_idxs, is_unsafe, block_addr), }, } } diff --git a/Ix/IxVM/Ingress.lean b/Ix/IxVM/Ingress.lean index ecf7f281..0a475eb0 100644 --- a/Ix/IxVM/Ingress.lean +++ b/Ix/IxVM/Ingress.lean @@ -175,7 +175,7 @@ def ingress := ⟦ match mc { MutConst.Indc(ind) => match ind { - Inductive.Mk(_, _, _, _, _, _, _, _, ctors) => + Inductive.Mk(_, _, _, _, _, ctors) => list_length(ctors) + 1, }, MutConst.Recr(_) => 1, @@ -850,7 +850,7 @@ def ingress := ⟦ match mc { MutConst.Indc(ind) => match ind { - Inductive.Mk(_, _, _, _, _, _, _, _, ctors) => + Inductive.Mk(_, _, _, _, _, ctors) => let num_ctors = list_length(ctors); let this_ctors = build_ctor_idxs(num_ctors, cur_pos, 0); let rest_ctors = build_rule_ctor_idxs_walk(rest, @@ -998,7 +998,7 @@ def ingress := ⟦ match mc { MutConst.Indc(ind) => match ind { - Inductive.Mk(_, _, _, _, _, _, _, _, ctors) => + Inductive.Mk(_, _, _, _, _, ctors) => build_ctor_idxs(list_length(ctors), cur_pos, 0), }, _ => store(ListNode.Nil), @@ -1027,7 +1027,7 @@ def ingress := ⟦ match mc { MutConst.Indc(ind) => match ind { - Inductive.Mk(_, _, _, _, _, _, _, _, ctors) => + Inductive.Mk(_, _, _, _, _, ctors) => let num_ctors = list_length(ctors); let induct_pos = block_start + member_offset(members, member_idx); let ctor_idxs = build_ctor_idxs(num_ctors, induct_pos, 0); @@ -1546,7 +1546,7 @@ def ingress := ⟦ match mc { MutConst.Indc(ind) => match ind { - Inductive.Mk(_, _, _, _, _, _, _, _, ctors) => + Inductive.Mk(_, _, _, _, _, ctors) => list_length(ctors), }, _ => 0, diff --git a/Ix/IxVM/Ixon.lean b/Ix/IxVM/Ixon.lean index c8d54a90..a0f425a2 100644 --- a/Ix/IxVM/Ixon.lean +++ b/Ix/IxVM/Ixon.lean @@ -83,9 +83,9 @@ def ixon := ⟦ Mk(G, U64, U64, U64, U64, &Expr) } - -- Inductive: (recr, refl, is_unsafe, lvls, params, indices, nested, typ, ctors) + -- Inductive: (is_unsafe, lvls, params, indices, typ, ctors) enum Inductive { - Mk(G, G, G, U64, U64, U64, U64, &Expr, List‹Constructor›) + Mk(G, U64, U64, U64, &Expr, List‹Constructor›) } -- InductiveProj: (idx, block_address) diff --git a/Ix/IxVM/IxonDeserialize.lean b/Ix/IxVM/IxonDeserialize.lean index 4a7cf34b..de89df8e 100644 --- a/Ix/IxVM/IxonDeserialize.lean +++ b/Ix/IxVM/IxonDeserialize.lean @@ -479,21 +479,18 @@ def ixonDeserialize := ⟦ } -- Inductive: byte(bools) + Tag0(lvls) + Tag0(params) + Tag0(indices) + - -- Tag0(nested) + expr(typ) + Tag0(ctors_len) + ctors... + -- expr(typ) + Tag0(ctors_len) + ctors... fn get_inductive(stream: ByteStream) -> (Inductive, ByteStream) { let (bools_byte, s) = read_byte(stream); let bits = u8_bit_decomposition(bools_byte); - let recr = bits[0]; - let refl = bits[1]; - let is_unsafe = bits[2]; + let is_unsafe = bits[0]; let (lvls, s2) = get_tag0(s); let (params, s3) = get_tag0(s2); let (indices, s4) = get_tag0(s3); - let (nested, s5) = get_tag0(s4); - let (typ, s6) = get_expr(s5); - let (ctors_len, s7) = get_tag0(s6); - let (ctors, s8) = get_constructor_list(s7, ctors_len); - (Inductive.Mk(recr, refl, is_unsafe, lvls, params, indices, nested, store(typ), ctors), s8) + let (typ, s5) = get_expr(s4); + let (ctors_len, s6) = get_tag0(s5); + let (ctors, s7) = get_constructor_list(s6, ctors_len); + (Inductive.Mk(is_unsafe, lvls, params, indices, store(typ), ctors), s7) } -- ============================================================================ diff --git a/Ix/IxVM/IxonSerialize.lean b/Ix/IxVM/IxonSerialize.lean index eeef3cab..6ae3d901 100644 --- a/Ix/IxVM/IxonSerialize.lean +++ b/Ix/IxVM/IxonSerialize.lean @@ -387,17 +387,15 @@ def ixonSerialize := ⟦ fn put_inductive(indc: Inductive, rest: ByteStream) -> ByteStream { match indc { - Inductive.Mk(recr, refl, is_unsafe, lvls, params, indices, nested, &typ, ctors) => - let bools = recr + 2 * refl + 4 * is_unsafe; + Inductive.Mk(is_unsafe, lvls, params, indices, &typ, ctors) => let ctors_len = list_length_u64(ctors); - store(ListNode.Cons(u8_from_field_unsafe(bools), + store(ListNode.Cons(u8_from_field_unsafe(is_unsafe), put_tag0(lvls, put_tag0(params, put_tag0(indices, - put_tag0(nested, - put_expr(typ, - put_tag0(ctors_len, - put_constructor_list(ctors, rest))))))))), + put_expr(typ, + put_tag0(ctors_len, + put_constructor_list(ctors, rest)))))))), } } diff --git a/Ix/IxVM/Kernel/CanonicalCheck.lean b/Ix/IxVM/Kernel/CanonicalCheck.lean index f45f260e..97133bb1 100644 --- a/Ix/IxVM/Kernel/CanonicalCheck.lean +++ b/Ix/IxVM/Kernel/CanonicalCheck.lean @@ -536,7 +536,7 @@ def canonicalCheck := ⟦ KConstantInfo.Defn(_, _, _, _, _) => 0, KConstantInfo.Thm(_, _, _) => 0, KConstantInfo.Opaque(_, _, _, _) => 0, - KConstantInfo.Induct(_, _, _, _, _, _, _, _, _, _) => 1, + KConstantInfo.Induct(_, _, _, _, _, _, _) => 1, KConstantInfo.Rec(_, _, _, _, _, _, _, _, _, _) => 2, KConstantInfo.Ctor(_, _, _, _, _, _, _) => 3, KConstantInfo.Axiom(_, _, _) => 4, @@ -586,18 +586,17 @@ def canonicalCheck := ⟦ ord_then(ord_cmp_g(xn, yn), ord_then(compare_kexpr(xt, yt), ord_cmp_g(xu, yu))), }, - -- Mirror: src/ix/kernel/canonical_check.rs:299-340 compare_kindc - -- order: (is_rec, is_unsafe, lvls, params, indices, ctors_len, ty, ctors). - KConstantInfo.Induct(xn, xt, xp, xi, xc, xr, _xrf, xu, _xne, _xa) => + -- Mirror: src/ix/kernel/canonical_check.rs compare_kindc + -- order: (is_unsafe, lvls, params, indices, ctors_len, ty, ctors). + KConstantInfo.Induct(xn, xt, xp, xi, xc, xu, _xa) => match y { - KConstantInfo.Induct(yn, yt, yp, yi, yc, yr, _yrf, yu, _yne, _ya) => - ord_then(ord_cmp_g(xr, yr), - ord_then(ord_cmp_g(xu, yu), - ord_then(ord_cmp_g(xn, yn), - ord_then(ord_cmp_g(xp, yp), - ord_then(ord_cmp_g(xi, yi), - ord_then(ord_cmp_g(list_length(xc), list_length(yc)), - compare_kexpr(xt, yt))))))), + KConstantInfo.Induct(yn, yt, yp, yi, yc, yu, _ya) => + ord_then(ord_cmp_g(xu, yu), + ord_then(ord_cmp_g(xn, yn), + ord_then(ord_cmp_g(xp, yp), + ord_then(ord_cmp_g(xi, yi), + ord_then(ord_cmp_g(list_length(xc), list_length(yc)), + compare_kexpr(xt, yt)))))), }, -- Mirror: src/ix/kernel/canonical_check.rs:346-368 compare_kctor -- order: (lvls, cidx, params, fields, ty). induct_idx + unsafe excluded @@ -677,16 +676,15 @@ def canonicalCheck := ⟦ sord_then(compare_kexpr_ctx(xt, yt, ctx), sord_of_g(ord_cmp_g(xu, yu)))), }, - KConstantInfo.Induct(xn, xt, xp, xi, xc, xr, _xrf, xu, _xne, _xa) => + KConstantInfo.Induct(xn, xt, xp, xi, xc, xu, _xa) => match y { - KConstantInfo.Induct(yn, yt, yp, yi, yc, yr, _yrf, yu, _yne, _ya) => - sord_then(sord_of_g(ord_cmp_g(xr, yr)), - sord_then(sord_of_g(ord_cmp_g(xu, yu)), - sord_then(sord_of_g(ord_cmp_g(xn, yn)), - sord_then(sord_of_g(ord_cmp_g(xp, yp)), - sord_then(sord_of_g(ord_cmp_g(xi, yi)), - sord_then(sord_of_g(ord_cmp_g(list_length(xc), list_length(yc))), - compare_kexpr_ctx(xt, yt, ctx))))))), + KConstantInfo.Induct(yn, yt, yp, yi, yc, yu, _ya) => + sord_then(sord_of_g(ord_cmp_g(xu, yu)), + sord_then(sord_of_g(ord_cmp_g(xn, yn)), + sord_then(sord_of_g(ord_cmp_g(xp, yp)), + sord_then(sord_of_g(ord_cmp_g(xi, yi)), + sord_then(sord_of_g(ord_cmp_g(list_length(xc), list_length(yc))), + compare_kexpr_ctx(xt, yt, ctx)))))), }, KConstantInfo.Ctor(xn, xt, _xi, xc, xp, xf, _xu) => match y { @@ -740,11 +738,11 @@ def canonicalCheck := ⟦ fn kconst_block_addr(ci: KConstantInfo, top: List‹&KConstantInfo›) -> Addr { match ci { - KConstantInfo.Induct(_, _, _, _, _, _, _, _, _, ba) => ba, + KConstantInfo.Induct(_, _, _, _, _, _, ba) => ba, KConstantInfo.Ctor(_, _, induct_idx, _, _, _, _) => let ind_ci = load(list_lookup(top, induct_idx)); match ind_ci { - KConstantInfo.Induct(_, _, _, _, _, _, _, _, _, ba) => ba, + KConstantInfo.Induct(_, _, _, _, _, _, ba) => ba, _ => store([0u8; 32]), }, KConstantInfo.Rec(_, _, _, _, _, _, _, _, _, ba) => ba, diff --git a/Ix/IxVM/Kernel/Check.lean b/Ix/IxVM/Kernel/Check.lean index f30a9078..d5c374fe 100644 --- a/Ix/IxVM/Kernel/Check.lean +++ b/Ix/IxVM/Kernel/Check.lean @@ -44,7 +44,7 @@ def check := ⟦ KConstantInfo.Thm(_, _, _) => 0, KConstantInfo.Opaque(_, _, _, u) => u, KConstantInfo.Quot(_, _, _) => 0, - KConstantInfo.Induct(_, _, _, _, _, _, _, u, _, _) => u, + KConstantInfo.Induct(_, _, _, _, _, u, _) => u, KConstantInfo.Ctor(_, _, _, _, _, _, u) => u, KConstantInfo.Rec(_, _, _, _, _, _, _, _, u, _) => u, } @@ -186,7 +186,7 @@ def check := ⟦ let eq_idx = find_addr_idx(eq_addr(), addrs, 0); let eq_ci = load(list_lookup(top, eq_idx)); match eq_ci { - KConstantInfo.Induct(num_lvls, _, n_params, _, ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(num_lvls, _, n_params, _, ctor_indices, _, _) => assert_eq!(num_lvls, 1); assert_eq!(n_params, 2); assert_eq!(list_length(ctor_indices), 1); @@ -246,20 +246,19 @@ def check := ⟦ let _ = check_quot(self_addr, kind, num_lvls, ty, top, addrs); (), - KConstantInfo.Induct(_, ty, n_params, n_indices, ctor_indices, - is_rec, _, _, _, block_addr) => + KConstantInfo.Induct(_, ty, n_params, n_indices, _, + _, block_addr) => let _ = k_ensure_sort(ty, store(ListNode.Nil), top, addrs); let _ = assert_safety(u, ty, top); let _ = check_block_peer_param_agreement(pos, ty, n_params, n_indices, block_addr, top, addrs); let block_idxs = derive_block_member_idxs(pos, top); let _ = validate_block_auxes(block_idxs, top); - -- H1: constructively recompute is_rec by scanning ctor field doms - -- for block-member references. Mirror src/ix/kernel/inductive.rs:309-315. - -- Without this, an adversary could set is_rec=0 on a recursive - -- 1-ctor inductive to enable struct-eta on a recursive structure. - let computed_is_rec = compute_is_rec(ctor_indices, n_params, block_idxs, top); - assert_eq!(is_rec, computed_is_rec); + -- The former H1 declared-vs-computed is_rec check is gone with the + -- Ixon recr flag: there is no declared value to verify. is_rec is + -- computed on demand (`computed_is_rec_ind`) wherever it matters + -- (struct-eta / unit-like gates), so an adversary has nothing to + -- forge. Mirror: check_inductive after `Ixon: drop recr/refl/nested`. (), -- Ctor cross-ref + return-type + field-universe + strict-positivity @@ -270,7 +269,7 @@ def check := ⟦ let _ = check_ctor_against_inductive_member(pos, ci, top); let ind_ci = load(list_lookup(top, induct_idx)); match ind_ci { - KConstantInfo.Induct(ind_num_lvls, ind_ty, ind_n_params, ind_n_indices, _, _, _, _, _, _) => + KConstantInfo.Induct(ind_num_lvls, ind_ty, ind_n_params, ind_n_indices, _, _, _) => assert_eq!(num_params, ind_n_params); -- A1 defense-in-depth: ctor's leading param domains must match -- parent inductive's. Mirror src/ix/kernel/inductive.rs:283,393. diff --git a/Ix/IxVM/Kernel/Claim.lean b/Ix/IxVM/Kernel/Claim.lean index ccfc9d15..73459418 100644 --- a/Ix/IxVM/Kernel/Claim.lean +++ b/Ix/IxVM/Kernel/Claim.lean @@ -63,8 +63,8 @@ def claim := ⟦ enum RevealMutConstInfo { Defn(Option‹DefKind›, Option‹DefinitionSafety›, Option‹U64›, Option‹Addr›, Option‹Addr›), - Indc(Option‹G›, Option‹G›, Option‹G›, - Option‹U64›, Option‹U64›, Option‹U64›, Option‹U64›, + Indc(Option‹G›, + Option‹U64›, Option‹U64›, Option‹U64›, Option‹Addr›, Option‹List‹(U64, RevealConstructorInfo)››), Recr(Option‹G›, Option‹G›, @@ -289,17 +289,14 @@ def claim := ⟦ let (value, s) = get_opt_addr_masked(b4, s); (RevealMutConstInfo.Defn(kind, safety, lvls, typ, value), s), 1 => - let (is_recr, s) = get_opt_bool_masked(b0, s); - let (refl, s) = get_opt_bool_masked(b1, s); - let (is_unsafe, s) = get_opt_bool_masked(b2, s); - let (lvls, s) = get_opt_u64_masked(b3, s); - let (params, s) = get_opt_u64_masked(b4, s); - let (indices, s) = get_opt_u64_masked(b5, s); - let (nested, s) = get_opt_u64_masked(b6, s); - let (typ, s) = get_opt_addr_masked(b7, s); - let (ctors, s) = get_opt_ctor_entry_list_masked(b8, s); - (RevealMutConstInfo.Indc(is_recr, refl, is_unsafe, lvls, params, - indices, nested, typ, ctors), s), + let (is_unsafe, s) = get_opt_bool_masked(b0, s); + let (lvls, s) = get_opt_u64_masked(b1, s); + let (params, s) = get_opt_u64_masked(b2, s); + let (indices, s) = get_opt_u64_masked(b3, s); + let (typ, s) = get_opt_addr_masked(b4, s); + let (ctors, s) = get_opt_ctor_entry_list_masked(b5, s); + (RevealMutConstInfo.Indc(is_unsafe, lvls, params, + indices, typ, ctors), s), 2 => let (k, s) = get_opt_bool_masked(b0, s); let (is_unsafe, s) = get_opt_bool_masked(b1, s); @@ -648,19 +645,16 @@ def claim := ⟦ }, MutConst.Indc(i) => match claimed { - RevealMutConstInfo.Indc(opt_recr, opt_refl, opt_unsafe, opt_lvls, - opt_params, opt_indices, opt_nested, + RevealMutConstInfo.Indc(opt_unsafe, opt_lvls, + opt_params, opt_indices, opt_typ, opt_ctors) => match i { - Inductive.Mk(r_recr, r_refl, r_unsafe, r_lvls, r_params, - r_indices, r_nested, r_typ, r_ctors) => - let _ = check_opt_bool(r_recr, opt_recr); - let _ = check_opt_bool(r_refl, opt_refl); + Inductive.Mk(r_unsafe, r_lvls, r_params, + r_indices, r_typ, r_ctors) => let _ = check_opt_bool(r_unsafe, opt_unsafe); let _ = check_opt_u64(r_lvls, opt_lvls); let _ = check_opt_u64(r_params, opt_params); let _ = check_opt_u64(r_indices, opt_indices); - let _ = check_opt_u64(r_nested, opt_nested); let _ = check_opt_expr_addr(r_typ, opt_typ); check_opt_ctor_entries(r_ctors, opt_ctors), }, diff --git a/Ix/IxVM/Kernel/DefEq.lean b/Ix/IxVM/Kernel/DefEq.lean index 64725adc..6ed74301 100644 --- a/Ix/IxVM/Kernel/DefEq.lean +++ b/Ix/IxVM/Kernel/DefEq.lean @@ -203,7 +203,10 @@ def defEq := ⟦ } } - -- 1 iff ty is `Const(I, _) args` for non-rec 1-ctor 0-field inductive. + -- 1 iff ty is `Const(I, _) args` for a 1-ctor 0-field inductive. + -- (A 0-field ctor cannot reference the block, so an is_rec check would + -- be redundant — mirror def_eq.rs try_unit_like, which dropped the flag + -- when Ixon stopped storing it.) fn is_unit_like_type(ty: KExpr, top: List‹&KConstantInfo›) -> G { match collect_spine(ty) { (head, _) => @@ -211,24 +214,20 @@ def defEq := ⟦ KExprNode.Const(idx, _) => let ci = load(list_lookup(top, idx)); match ci { - KConstantInfo.Induct(_, _, _, _, ctor_indices, is_rec, _, _, _, _) => - match is_rec { - 1 => 0, - 0 => - match list_length(ctor_indices) { - 1 => - let ctor_idx = list_lookup(ctor_indices, 0); - let ctor_ci = load(list_lookup(top, ctor_idx)); - match ctor_ci { - KConstantInfo.Ctor(_, _, _, _, _, n_fields, _) => - match n_fields { - 0 => 1, - _ => 0, - }, + KConstantInfo.Induct(_, _, _, _, ctor_indices, _, _) => + match list_length(ctor_indices) { + 1 => + let ctor_idx = list_lookup(ctor_indices, 0); + let ctor_ci = load(list_lookup(top, ctor_idx)); + match ctor_ci { + KConstantInfo.Ctor(_, _, _, _, _, n_fields, _) => + match n_fields { + 0 => 1, _ => 0, }, _ => 0, }, + _ => 0, }, _ => 0, }, @@ -379,15 +378,21 @@ def defEq := ⟦ match arity_diff { 0 => match load(list_lookup(top, induct_idx)) { - KConstantInfo.Induct(_, _, _, n_indices, ctor_indices, is_rec, _, _, _, _) => - let struct_like = eq_zero(is_rec) * eq_zero(n_indices) * - eq_zero(list_length(ctor_indices) - 1); - match struct_like { + KConstantInfo.Induct(_, _, _, n_indices, ctor_indices, _, _) => + -- struct-like: 0 indices, 1 ctor, computed non-rec + -- (recr flag dropped from Ixon; mirror is_struct_like). + let shape_ok = eq_zero(n_indices) * + eq_zero(list_length(ctor_indices) - 1); + match shape_ok { 0 => 0, 1 => - compare_struct_fields(induct_idx, num_params, - num_fields, t, s_args, 0, - types, top, addrs), + match computed_is_rec_ind(induct_idx, top) { + 1 => 0, + 0 => + compare_struct_fields(induct_idx, num_params, + num_fields, t, s_args, 0, + types, top, addrs), + }, }, _ => 0, }, diff --git a/Ix/IxVM/Kernel/Inductive.lean b/Ix/IxVM/Kernel/Inductive.lean index 101cbe33..06c1a9fb 100644 --- a/Ix/IxVM/Kernel/Inductive.lean +++ b/Ix/IxVM/Kernel/Inductive.lean @@ -254,7 +254,7 @@ def inductive_check := ⟦ -- inductive app". let ci = load(list_lookup(top, idx)); match ci { - KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, _, _, _, ext_block_addr) => + KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, ext_block_addr) => let after_params = list_drop(args, n_params); assert_eq!(list_any_mentions(after_params, block_idxs), 0); let aug = augment_block_idxs(block_idxs, ext_block_addr, top); @@ -284,10 +284,24 @@ def inductive_check := ⟦ } } - -- Returns 1 iff `e` contains any Const(idx) with idx in `idxs`. - -- Mirror: src/ix/kernel/inductive.rs:448-483 fn compute_is_rec. - -- Constructively recompute is_rec by scanning each ctor's field domains - -- (post n_params peeling) for any reference to a block member's idx. + -- Mirror: src/ix/kernel/inductive.rs fn computed_is_rec. Ixon no longer + -- stores the recr flag; is_rec is computed on demand from constructor + -- structure. Aiur memoization is the is_rec_cache (keyed on induct_idx); + -- no cycle-breaking needed because `compute_is_rec` is structural (no + -- whnf), unlike the Rust version. + fn computed_is_rec_ind(induct_idx: G, top: List‹&KConstantInfo›) -> G { + let ci = load(list_lookup(top, induct_idx)); + match ci { + KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, _) => + let block_idxs = derive_block_member_idxs(induct_idx, top); + compute_is_rec(ctor_indices, n_params, block_idxs, top), + _ => 0, + } + } + + -- Mirror: src/ix/kernel/inductive.rs fn compute_is_rec. + -- Compute is_rec by scanning each ctor's field domains (post n_params + -- peeling) for any reference to a block member's idx. -- Returns 1 iff at least one field domain mentions a block_idx. fn compute_is_rec(ctors: List‹G›, n_params: G, block_idxs: List‹G›, top: List‹&KConstantInfo›) -> G { @@ -383,7 +397,7 @@ def inductive_check := ⟦ ListNode.Nil => block_idxs, ListNode.Cons(&ci, rest) => match ci { - KConstantInfo.Induct(_, _, _, _, _, _, _, _, _, ba) => + KConstantInfo.Induct(_, _, _, _, _, _, ba) => let same = address_eq(ba, ext_block_addr); let nonzero = 1 - address_eq(ext_block_addr, store([0u8; 32])); let already = list_contains_g(block_idxs, idx); @@ -927,7 +941,7 @@ def inductive_check := ⟦ fn derive_block_member_idxs(ind_idx: G, top: List‹&KConstantInfo›) -> List‹G› { let ci = load(list_lookup(top, ind_idx)); match ci { - KConstantInfo.Induct(_, _, _, _, _, _, _, _, _, block_addr) => + KConstantInfo.Induct(_, _, _, _, _, _, block_addr) => match address_eq(block_addr, store([0u8; 32])) { 1 => store(ListNode.Cons(ind_idx, store(ListNode.Nil))), 0 => collect_block_members(block_addr, top, 0), @@ -942,7 +956,7 @@ def inductive_check := ⟦ ListNode.Nil => store(ListNode.Nil), ListNode.Cons(&ci, rest) => match ci { - KConstantInfo.Induct(_, _, _, _, _, _, _, _, _, ba) => + KConstantInfo.Induct(_, _, _, _, _, _, ba) => match address_eq(ba, block_addr) { 1 => store(ListNode.Cons(idx, collect_block_members(block_addr, rest, idx + 1))), 0 => collect_block_members(block_addr, rest, idx + 1), @@ -958,13 +972,13 @@ def inductive_check := ⟦ fn is_in_same_block(idx: G, ind_idx: G, top: List‹&KConstantInfo›) -> G { let i_ci = load(list_lookup(top, ind_idx)); match i_ci { - KConstantInfo.Induct(_, _, _, _, _, _, _, _, _, ind_ba) => + KConstantInfo.Induct(_, _, _, _, _, _, ind_ba) => match address_eq(ind_ba, store([0u8; 32])) { 1 => 0, 0 => let other_ci = load(list_lookup(top, idx)); match other_ci { - KConstantInfo.Induct(_, _, _, _, _, _, _, _, _, other_ba) => + KConstantInfo.Induct(_, _, _, _, _, _, other_ba) => address_eq(other_ba, ind_ba), _ => 0, }, @@ -1209,8 +1223,7 @@ def inductive_check := ⟦ (member_idx, is_aux, spec_params, occ_us) => let ci = load(list_lookup(top, member_idx)); match ci { - KConstantInfo.Induct(_, m_ind_ty, m_own_params, m_n_indices, - _, _, _, _, _, _) => + KConstantInfo.Induct(_, m_ind_ty, m_own_params, m_n_indices, _, _, _) => let mt = build_motive_type_flat(member_idx, m_ind_ty, m_own_params, m_n_indices, occ_us, elim_level, n_rec_params, @@ -1262,7 +1275,7 @@ def inductive_check := ⟦ (member_idx, is_aux, spec_params, occ_us) => let ci = load(list_lookup(top, member_idx)); match ci { - KConstantInfo.Induct(_, _, _, _, m_ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(_, _, _, _, m_ctor_indices, _, _) => let m_minors = build_minor_doms(m_ctor_indices, member_idx, is_aux, spec_params, occ_us, full_flat, flat_idxs, @@ -1694,7 +1707,7 @@ def inductive_check := ⟦ KConstantInfo.Ctor(_, _, induct_idx, cidx, _, _, _) => let ind_ci = load(list_lookup(top, induct_idx)); match ind_ci { - KConstantInfo.Induct(_, _, _, _, ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(_, _, _, _, ctor_indices, _, _) => let expected = list_lookup(ctor_indices, cidx); assert_eq!(expected, ctor_idx); (), @@ -1708,8 +1721,7 @@ def inductive_check := ⟦ fn compute_k_target(ind_idx: G, top: List‹&KConstantInfo›) -> G { let ind_ci = load(list_lookup(top, ind_idx)); match ind_ci { - KConstantInfo.Induct(_, ind_ty, n_params, n_indices, ctor_indices, - _, _, _, _, _) => + KConstantInfo.Induct(_, ind_ty, n_params, n_indices, ctor_indices, _, _) => let block_members = derive_block_member_idxs(ind_idx, top); match list_length(block_members) - 1 { 0 => @@ -1813,11 +1825,9 @@ def inductive_check := ⟦ let primary_ci = load(list_lookup(top, ind_idx)); let self_ci = load(list_lookup(top, self_major)); match primary_ci { - KConstantInfo.Induct(ind_lvls, ind_ty, ind_n_params, _, - _, _, _, _, _, _) => + KConstantInfo.Induct(ind_lvls, ind_ty, ind_n_params, _, _, _, _) => match self_ci { - KConstantInfo.Induct(_, self_ind_ty, self_own_params, self_n_indices, - self_ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(_, self_ind_ty, self_own_params, self_n_indices, self_ctor_indices, _, _) => let canonical_ty = build_rec_type(self_major, self_ind_ty, self_ctor_indices, ind_n_params, self_n_indices, ind_lvls, self_own_params, ind_idx, top, addrs); @@ -1921,7 +1931,7 @@ def inductive_check := ⟦ -> List‹(G, List‹KExpr›, List‹KLevel›)› { let ci = load(list_lookup(top, m_idx)); match ci { - KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, _) => detect_nested_in_member_ctors(ctor_indices, n_params, is_aux, spec_params, occ_us, block_idxs, top), _ => store(ListNode.Nil), @@ -2000,7 +2010,7 @@ def inductive_check := ⟦ ListNode.Cons(idx, rest) => let ci = load(list_lookup(top, idx)); match ci { - KConstantInfo.Induct(lvls, _, _, _, _, _, _, _, _, _) => + KConstantInfo.Induct(lvls, _, _, _, _, _, _) => let occ_us = build_param_lvls_range(univ_offset, lvls, 0); store(ListNode.Cons((idx, 0, store(ListNode.Nil), occ_us), build_flat_originals(rest, univ_offset, top))), @@ -2058,7 +2068,7 @@ def inductive_check := ⟦ (ind_idx, _, _, _) => let ci = load(list_lookup(top, ind_idx)); match ci { - KConstantInfo.Induct(_, _, np, _, _, _, _, _, _, _) => + KConstantInfo.Induct(_, _, np, _, _, _, _) => store(ListNode.Cons(np, flat_own_params_of(rest, top))), _ => store(ListNode.Cons(0, flat_own_params_of(rest, top))), @@ -2084,6 +2094,39 @@ def inductive_check := ⟦ } } + -- Returns 1 iff `idx`'s own ctor fields contain a nested occurrence + -- (external inductive applied to args mentioning block members). + -- Structural replacement for the dropped Ixon `nested` count: an + -- original of a nested-emitting block detects non-empty; an aux (whose + -- specialized ctors reference only block members) and a pure-mutual + -- peer detect empty. Aiur memoization caches per (idx, block, top). + fn member_has_nested(idx: G, block_idxs: List‹G›, + top: List‹&KConstantInfo›) -> G { + let nested = detect_nested_in_orig(idx, block_idxs, top); + match load(nested) { + ListNode.Nil => 0, + _ => 1, + } + } + + fn any_member_has_nested(walk_idxs: List‹G›, block_idxs: List‹G›, + top: List‹&KConstantInfo›) -> G { + match load(walk_idxs) { + ListNode.Nil => 0, + ListNode.Cons(idx, rest) => + match member_has_nested(idx, block_idxs, top) { + 1 => 1, + 0 => any_member_has_nested(rest, block_idxs, top), + }, + } + } + + -- Returns 1 iff `ind_idx`'s block emits nested auxes. + fn ind_has_nested(ind_idx: G, top: List‹&KConstantInfo›) -> G { + let block_idxs = derive_block_member_idxs(ind_idx, top); + any_member_has_nested(block_idxs, block_idxs, top) + } + fn scan_primary_in_rec_block(rec_block: Addr, consts: List‹&KConstantInfo›, top: List‹&KConstantInfo›, idx: G) -> (G, G) { @@ -2098,8 +2141,8 @@ def inductive_check := ⟦ let r_ind = rec_to_ind_idx_with_ty(rules, ty, n_p, n_m, n_min, n_i, top); let r_ci = load(list_lookup(top, r_ind)); match r_ci { - KConstantInfo.Induct(_, _, _, _, _, _, _, _, ne, _) => - match ne { + KConstantInfo.Induct(_, _, _, _, _, _, _) => + match ind_has_nested(r_ind, top) { 0 => scan_primary_in_rec_block(rec_block, rest, top, idx + 1), _ => (1, r_ind), }, @@ -2122,7 +2165,7 @@ def inductive_check := ⟦ 0 => let ci = load(list_lookup(top, member_idx)); match ci { - KConstantInfo.Induct(_, _, _, _, m_ctors, _, _, _, _, _) => + KConstantInfo.Induct(_, _, _, _, m_ctors, _, _) => ctors_before_member(rest, target_ind_idx, top, acc + list_length(m_ctors)), _ => ctors_before_member(rest, target_ind_idx, top, acc), @@ -2131,19 +2174,21 @@ def inductive_check := ⟦ } } - -- Returns 1 iff `ci_idx` is an auxiliary - -- Inductive in its block. Aux iff: in non-solo block AND own nested=0 - -- AND some other member of the block has nested>0 (i.e., the block is - -- a nested-emitting block, not pure mutual). + -- Returns 1 iff `ci_idx` is an auxiliary Inductive in its block. + -- Aux iff: in a non-solo block AND own ctors contain no nested + -- occurrence AND some block member's do (i.e., the block is a + -- nested-emitting block, not pure mutual). Structural — the Ixon + -- `nested` count this used to read was dropped. fn is_aux_inductive(ci_idx: G, top: List‹&KConstantInfo›) -> G { let ci = load(list_lookup(top, ci_idx)); match ci { - KConstantInfo.Induct(_, _, _, _, _, _, _, _, this_nested, this_block_addr) => + KConstantInfo.Induct(_, _, _, _, _, _, this_block_addr) => match address_eq(this_block_addr, store([0u8; 32])) { 1 => 0, 0 => - match this_nested { - 0 => block_has_some_nested(this_block_addr, top, 0), + let block_idxs = derive_block_member_idxs(ci_idx, top); + match member_has_nested(ci_idx, block_idxs, top) { + 0 => any_member_has_nested(block_idxs, block_idxs, top), _ => 0, }, }, @@ -2151,25 +2196,6 @@ def inductive_check := ⟦ } } - -- Returns 1 iff some Inductive in `top` shares `target_block` AND has - -- nested > 0 (i.e., it's an original in a nested-emitting block). - fn block_has_some_nested(target_block: Addr, - consts: List‹&KConstantInfo›, idx: G) -> G { - match load(consts) { - ListNode.Nil => 0, - ListNode.Cons(&ci, rest) => - match ci { - KConstantInfo.Induct(_, _, _, _, _, _, _, _, n, ba) => - let same = address_eq(ba, target_block); - match same * n { - 0 => block_has_some_nested(target_block, rest, idx + 1), - _ => 1, - }, - _ => block_has_some_nested(target_block, rest, idx + 1), - }, - } - } - -- Mirror: src/ix/kernel/inductive.rs:619+ -- fn try_detect_nested. For each ctor of `orig_idx`, walk its fields; -- for each field's domain, peel leading Foralls + check spine head: @@ -2180,7 +2206,7 @@ def inductive_check := ⟦ -> List‹(G, List‹KExpr›, List‹KLevel›)› { let orig_ci = load(list_lookup(top, orig_idx)); match orig_ci { - KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, _) => detect_nested_in_ctors(ctor_indices, n_params, block_idxs, top), _ => store(ListNode.Nil), } @@ -2231,7 +2257,7 @@ def inductive_check := ⟦ 0 => let ci = load(list_lookup(top, idx)); match ci { - KConstantInfo.Induct(_, _, ext_n_params, _, _, _, _, _, _, _) => + KConstantInfo.Induct(_, _, ext_n_params, _, _, _, _) => let n_args = list_length(args); match u32_less_than(n_args, ext_n_params) { 1 => store(ListNode.Nil), @@ -2313,7 +2339,7 @@ def inductive_check := ⟦ 0 => let ci = load(list_lookup(top, idx)); match ci { - KConstantInfo.Induct(_, ind_ty, n_params, _, _, _, _, _, _, _) => + KConstantInfo.Induct(_, ind_ty, n_params, _, _, _, _) => let walk = collect_n_doms(ind_ty, n_params); match walk { (doms, _) => (n_params, doms), @@ -2355,7 +2381,7 @@ def inductive_check := ⟦ 1 => let aux_ci = load(list_lookup(top, idx)); match aux_ci { - KConstantInfo.Induct(_, aux_ind_ty, _, _, aux_ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(_, aux_ind_ty, _, _, aux_ctor_indices, _, _) => let matched = try_match_aux(aux_ind_ty, aux_ctor_indices, nested_list, n_block_params, block_param_doms, top); assert_eq!(matched, 1); @@ -2380,7 +2406,7 @@ def inductive_check := ⟦ (ext_idx, spec_params, _occ_us) => let ext_ci = load(list_lookup(top, ext_idx)); match ext_ci { - KConstantInfo.Induct(_, ext_ind_ty, ext_n_params, _, ext_ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(_, ext_ind_ty, ext_n_params, _, ext_ctor_indices, _, _) => let body = synth_aux_ind_ty(ext_ind_ty, ext_n_params, spec_params); let synth = wrap_foralls(body, block_param_doms); let cmp = compare_kexpr(synth, aux_ind_ty); @@ -2555,8 +2581,7 @@ def inductive_check := ⟦ ListNode.Nil => (), ListNode.Cons(&ci, rest) => match ci { - KConstantInfo.Induct(_, peer_ty, peer_n_params, peer_n_indices, _, - _, _, _, _, peer_block_addr) => + KConstantInfo.Induct(_, peer_ty, peer_n_params, peer_n_indices, _, _, peer_block_addr) => let same_block = address_eq(peer_block_addr, block_addr); let is_self = eq_zero(idx - self_pos); let should_check = same_block * (1 - is_self); diff --git a/Ix/IxVM/Kernel/Infer.lean b/Ix/IxVM/Kernel/Infer.lean index ef08b7a2..4190ed39 100644 --- a/Ix/IxVM/Kernel/Infer.lean +++ b/Ix/IxVM/Kernel/Infer.lean @@ -133,7 +133,7 @@ def infer := ⟦ assert_eq!(idx, tidx); let ind_ci = load(list_lookup(top, idx)); match ind_ci { - KConstantInfo.Induct(_, ind_ty, n_params, n_indices, ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(_, ind_ty, n_params, n_indices, ctor_indices, _, _) => -- Single-ctor structure required. assert_eq!(list_length(ctor_indices), 1); let is_prop = is_inductive_prop(ind_ty, lvls, n_params + n_indices, @@ -324,7 +324,7 @@ def infer := ⟦ assert_eq!(idx, tidx); let ind_ci = load(list_lookup(top, idx)); match ind_ci { - KConstantInfo.Induct(_, ind_ty, n_params, n_indices, ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(_, ind_ty, n_params, n_indices, ctor_indices, _, _) => assert_eq!(list_length(ctor_indices), 1); let is_prop = is_inductive_prop(ind_ty, lvls, n_params + n_indices, types, top, addrs); @@ -369,7 +369,7 @@ def infer := ⟦ KConstantInfo.Thm(_, ty, _) => ty, KConstantInfo.Opaque(_, ty, _, _) => ty, KConstantInfo.Quot(_, ty, _) => ty, - KConstantInfo.Induct(_, ty, _, _, _, _, _, _, _, _) => ty, + KConstantInfo.Induct(_, ty, _, _, _, _, _) => ty, KConstantInfo.Ctor(_, ty, _, _, _, _, _) => ty, KConstantInfo.Rec(_, ty, _, _, _, _, _, _, _, _) => ty, } @@ -383,7 +383,7 @@ def infer := ⟦ KConstantInfo.Thm(n, _, _) => n, KConstantInfo.Opaque(n, _, _, _) => n, KConstantInfo.Quot(n, _, _) => n, - KConstantInfo.Induct(n, _, _, _, _, _, _, _, _, _) => n, + KConstantInfo.Induct(n, _, _, _, _, _, _) => n, KConstantInfo.Ctor(n, _, _, _, _, _, _) => n, KConstantInfo.Rec(n, _, _, _, _, _, _, _, _, _) => n, } diff --git a/Ix/IxVM/Kernel/Primitive.lean b/Ix/IxVM/Kernel/Primitive.lean index 4fc70c9c..ccdf131f 100644 --- a/Ix/IxVM/Kernel/Primitive.lean +++ b/Ix/IxVM/Kernel/Primitive.lean @@ -57,10 +57,10 @@ def primitive := ⟦ } fn quot_lift_addr() -> Addr { - store([0xaau8, 0x57u8, 0xe8u8, 0xc3u8, 0xf4u8, 0xf9u8, 0xe1u8, 0xcfu8, - 0x6bu8, 0x02u8, 0xa0u8, 0x38u8, 0xacu8, 0x15u8, 0x81u8, 0x98u8, - 0xc3u8, 0xafu8, 0x4bu8, 0x28u8, 0xd6u8, 0x1cu8, 0xeau8, 0x79u8, - 0x95u8, 0xbfu8, 0x5cu8, 0xa7u8, 0xc7u8, 0xb8u8, 0x2cu8, 0x29u8]) + store([0x8du8, 0xc4u8, 0xa9u8, 0x75u8, 0x27u8, 0x81u8, 0x2fu8, 0x8bu8, + 0x78u8, 0x17u8, 0xb7u8, 0x7cu8, 0xd0u8, 0x79u8, 0xacu8, 0xe6u8, + 0x14u8, 0x50u8, 0xaau8, 0x01u8, 0x85u8, 0xacu8, 0x58u8, 0x85u8, + 0x66u8, 0x1eu8, 0xc2u8, 0xacu8, 0xbau8, 0x8bu8, 0x7bu8, 0xd0u8]) } fn quot_ind_addr() -> Addr { @@ -71,122 +71,122 @@ def primitive := ⟦ } fn bit_vec_addr() -> Addr { - store([0x33u8, 0xd9u8, 0x4au8, 0x2du8, 0x25u8, 0x0au8, 0x1au8, 0x5au8, - 0xa0u8, 0x22u8, 0xe3u8, 0xbeu8, 0xfdu8, 0xcau8, 0x1cu8, 0x86u8, - 0xf4u8, 0x5du8, 0x70u8, 0x07u8, 0x1du8, 0xb0u8, 0x38u8, 0xefu8, - 0xf9u8, 0xb8u8, 0x98u8, 0x0du8, 0xc5u8, 0x16u8, 0x0bu8, 0x76u8]) + store([0x69u8, 0x8du8, 0xd5u8, 0x93u8, 0xabu8, 0xfbu8, 0x63u8, 0xdbu8, + 0x36u8, 0x2au8, 0xaeu8, 0xf5u8, 0x7eu8, 0x70u8, 0xa7u8, 0x93u8, + 0x04u8, 0x4fu8, 0xb6u8, 0x57u8, 0x25u8, 0x72u8, 0x91u8, 0xeeu8, + 0x2cu8, 0x3eu8, 0x99u8, 0x7cu8, 0xaau8, 0x42u8, 0x3eu8, 0xaeu8]) } fn bit_vec_to_nat_addr() -> Addr { - store([0xf9u8, 0x42u8, 0x71u8, 0x48u8, 0x2fu8, 0xfdu8, 0xfdu8, 0x78u8, - 0x02u8, 0xd4u8, 0x2eu8, 0x22u8, 0x27u8, 0x1cu8, 0x89u8, 0xe2u8, - 0x1du8, 0xeeu8, 0x45u8, 0x6bu8, 0x05u8, 0x08u8, 0x59u8, 0xc5u8, - 0xd1u8, 0x2eu8, 0x3du8, 0x1du8, 0x69u8, 0x9bu8, 0xb4u8, 0xeau8]) + store([0x77u8, 0xa0u8, 0x25u8, 0xc1u8, 0x9fu8, 0x8bu8, 0xe1u8, 0x31u8, + 0xfbu8, 0x9du8, 0x5bu8, 0x0bu8, 0xecu8, 0x49u8, 0x48u8, 0x17u8, + 0xa2u8, 0x65u8, 0x38u8, 0xb9u8, 0xa5u8, 0x50u8, 0xabu8, 0xbbu8, + 0xceu8, 0xc8u8, 0x09u8, 0x9fu8, 0xaeu8, 0x9du8, 0xe4u8, 0xe4u8]) } fn bit_vec_of_nat_addr() -> Addr { - store([0x2au8, 0xcbu8, 0x89u8, 0x42u8, 0xf3u8, 0x58u8, 0x7du8, 0x0au8, - 0xebu8, 0xf1u8, 0x79u8, 0x5du8, 0xf9u8, 0x04u8, 0x26u8, 0xeau8, - 0xffu8, 0x54u8, 0xe7u8, 0xf3u8, 0xccu8, 0xceu8, 0x36u8, 0xc5u8, - 0x89u8, 0xd5u8, 0xd1u8, 0x47u8, 0x16u8, 0xa7u8, 0x8fu8, 0xadu8]) + store([0x90u8, 0xcau8, 0x81u8, 0x30u8, 0x73u8, 0x5cu8, 0x8du8, 0x9au8, + 0x34u8, 0x00u8, 0x5au8, 0x89u8, 0x43u8, 0xb5u8, 0x9fu8, 0xe1u8, + 0xdfu8, 0x18u8, 0x2eu8, 0x08u8, 0xa9u8, 0xf2u8, 0xbfu8, 0xc7u8, + 0xdcu8, 0x83u8, 0x23u8, 0x22u8, 0x96u8, 0x59u8, 0xa5u8, 0x74u8]) } fn bit_vec_ult_addr() -> Addr { - store([0x06u8, 0x8au8, 0x88u8, 0x41u8, 0x0eu8, 0xf4u8, 0x45u8, 0xd3u8, - 0x1au8, 0xe5u8, 0x8eu8, 0x0eu8, 0x11u8, 0xb3u8, 0x68u8, 0x41u8, - 0x43u8, 0xe4u8, 0x72u8, 0x28u8, 0x8bu8, 0xd4u8, 0xa8u8, 0x84u8, - 0xd5u8, 0xf9u8, 0x28u8, 0xc3u8, 0xd2u8, 0x01u8, 0x9bu8, 0xecu8]) + store([0x9fu8, 0xd8u8, 0xe7u8, 0x45u8, 0x9au8, 0x1du8, 0x2du8, 0xeeu8, + 0xf0u8, 0x0au8, 0x49u8, 0x92u8, 0xa5u8, 0x04u8, 0x19u8, 0xbau8, + 0xc6u8, 0x6cu8, 0x03u8, 0x08u8, 0x2bu8, 0x58u8, 0xadu8, 0xe0u8, + 0x74u8, 0x22u8, 0x89u8, 0x6fu8, 0x13u8, 0x03u8, 0x3du8, 0x74u8]) } fn decidable_decide_addr() -> Addr { - store([0xf4u8, 0xcdu8, 0xbcu8, 0x5eu8, 0xd9u8, 0xa1u8, 0xabu8, 0x59u8, - 0x28u8, 0xf9u8, 0x93u8, 0x1fu8, 0x5cu8, 0x23u8, 0x90u8, 0x23u8, - 0x9eu8, 0x7fu8, 0x47u8, 0xdfu8, 0x6du8, 0x20u8, 0xe8u8, 0x4eu8, - 0xa4u8, 0x65u8, 0xc9u8, 0x70u8, 0x7bu8, 0x84u8, 0xcdu8, 0xc1u8]) + store([0xc5u8, 0xf7u8, 0xb1u8, 0x96u8, 0x63u8, 0xe4u8, 0x49u8, 0x9eu8, + 0x70u8, 0xe1u8, 0xb2u8, 0x64u8, 0x51u8, 0x62u8, 0xc5u8, 0xbeu8, + 0x15u8, 0xfau8, 0x86u8, 0x0fu8, 0x4fu8, 0x81u8, 0x57u8, 0xe3u8, + 0x31u8, 0xaeu8, 0x54u8, 0x6cu8, 0x6fu8, 0x73u8, 0x37u8, 0x23u8]) } fn lt_lt_addr() -> Addr { - store([0x01u8, 0xd8u8, 0x71u8, 0xbcu8, 0xdfu8, 0xb2u8, 0xe7u8, 0x69u8, - 0xe1u8, 0xacu8, 0xa0u8, 0x0eu8, 0x7au8, 0x3bu8, 0x3au8, 0x21u8, - 0xa8u8, 0xd9u8, 0x02u8, 0xccu8, 0x27u8, 0x37u8, 0x07u8, 0xc8u8, - 0x92u8, 0xebu8, 0x86u8, 0x7bu8, 0x7fu8, 0xc7u8, 0x8au8, 0xe2u8]) + store([0xcau8, 0xcau8, 0xeau8, 0x97u8, 0xf4u8, 0xcdu8, 0xbau8, 0x0au8, + 0x4au8, 0x0au8, 0xf7u8, 0x10u8, 0x05u8, 0xd0u8, 0x51u8, 0x7du8, + 0x18u8, 0x18u8, 0xabu8, 0x26u8, 0x23u8, 0xbdu8, 0x2eu8, 0xa7u8, + 0xfau8, 0x8cu8, 0x63u8, 0x7au8, 0x0eu8, 0x3du8, 0x33u8, 0x12u8]) } fn bool_type_addr() -> Addr { - store([0x64u8, 0x05u8, 0xa4u8, 0x55u8, 0xbau8, 0x70u8, 0xc2u8, 0xb2u8, - 0x17u8, 0x9cu8, 0x79u8, 0x66u8, 0xc6u8, 0xf6u8, 0x10u8, 0xbfu8, - 0x34u8, 0x17u8, 0xbdu8, 0x0fu8, 0x3du8, 0xd2u8, 0xbau8, 0x7au8, - 0x52u8, 0x25u8, 0x33u8, 0xc2u8, 0xcdu8, 0x9eu8, 0x1du8, 0x0bu8]) + store([0xe6u8, 0xebu8, 0xa3u8, 0xc8u8, 0xb4u8, 0xd1u8, 0x9fu8, 0x6au8, + 0x10u8, 0x76u8, 0xb3u8, 0x9fu8, 0xa8u8, 0x9au8, 0xecu8, 0x61u8, + 0xdcu8, 0xcbu8, 0xb9u8, 0x60u8, 0xf8u8, 0x3du8, 0x9au8, 0x62u8, + 0xe6u8, 0xacu8, 0xf3u8, 0x5au8, 0x69u8, 0xc9u8, 0xa0u8, 0xa4u8]) } fn eq_addr() -> Addr { - store([0x9cu8, 0x0au8, 0xf2u8, 0xa3u8, 0x93u8, 0xcbu8, 0x5cu8, 0x08u8, - 0x35u8, 0xe4u8, 0x4eu8, 0x60u8, 0xe4u8, 0xc3u8, 0xe6u8, 0x8eu8, - 0xebu8, 0x26u8, 0x6fu8, 0xd1u8, 0x6au8, 0xffu8, 0xadu8, 0x32u8, - 0x16u8, 0x09u8, 0x6au8, 0x35u8, 0xfeu8, 0x91u8, 0xb9u8, 0xc1u8]) + store([0x03u8, 0x6bu8, 0x63u8, 0xd5u8, 0xccu8, 0x09u8, 0x61u8, 0xe9u8, + 0x20u8, 0xdeu8, 0xe5u8, 0x0eu8, 0x73u8, 0x64u8, 0xecu8, 0x0du8, + 0xd3u8, 0xf9u8, 0xc3u8, 0x8au8, 0x9cu8, 0xacu8, 0xe4u8, 0x0eu8, + 0x51u8, 0x3bu8, 0x38u8, 0x35u8, 0xdeu8, 0xc8u8, 0xe0u8, 0xc9u8]) } fn eq_refl_addr() -> Addr { - store([0x1eu8, 0x25u8, 0x11u8, 0x98u8, 0xf3u8, 0x06u8, 0x25u8, 0x62u8, - 0x8eu8, 0x2eu8, 0xb0u8, 0x98u8, 0x3fu8, 0x7bu8, 0xe9u8, 0xefu8, - 0xe8u8, 0xd7u8, 0x19u8, 0xa1u8, 0x04u8, 0xa8u8, 0x61u8, 0xf2u8, - 0xbeu8, 0xf2u8, 0xf4u8, 0x7eu8, 0xabu8, 0xeeu8, 0xd4u8, 0xf9u8]) + store([0x6cu8, 0x9bu8, 0xd6u8, 0x0eu8, 0x1eu8, 0xaeu8, 0x93u8, 0x8eu8, + 0x56u8, 0x26u8, 0xcau8, 0x23u8, 0x7du8, 0xbcu8, 0xa7u8, 0xfdu8, + 0x95u8, 0x0fu8, 0x2eu8, 0x99u8, 0xe2u8, 0x34u8, 0xa9u8, 0x9cu8, + 0x23u8, 0xcfu8, 0xdcu8, 0x29u8, 0x4cu8, 0xa7u8, 0xadu8, 0xceu8]) } fn nat_dec_le_addr() -> Addr { - store([0xe2u8, 0xd8u8, 0x29u8, 0x2eu8, 0x1au8, 0xdfu8, 0x54u8, 0xb0u8, - 0xd3u8, 0x93u8, 0x00u8, 0x84u8, 0x77u8, 0x18u8, 0xdcu8, 0x89u8, - 0xa6u8, 0x33u8, 0x32u8, 0xe8u8, 0xf3u8, 0x1bu8, 0x41u8, 0xc9u8, - 0xe8u8, 0x0fu8, 0x8cu8, 0x9au8, 0x20u8, 0x17u8, 0x27u8, 0x8du8]) + store([0xecu8, 0x1fu8, 0x60u8, 0xc1u8, 0xa2u8, 0x8du8, 0x48u8, 0xbcu8, + 0x98u8, 0xfeu8, 0x3eu8, 0xf7u8, 0x2du8, 0x25u8, 0x51u8, 0x32u8, + 0x73u8, 0x5au8, 0x50u8, 0x3cu8, 0xc3u8, 0x6eu8, 0x3fu8, 0xf0u8, + 0xf2u8, 0x2eu8, 0x3du8, 0x48u8, 0x6eu8, 0x26u8, 0x6eu8, 0xbeu8]) } fn nat_dec_eq_addr() -> Addr { - store([0x86u8, 0x29u8, 0x51u8, 0x96u8, 0x32u8, 0xe1u8, 0x8cu8, 0x49u8, - 0x09u8, 0x79u8, 0x36u8, 0xfcu8, 0x22u8, 0x0cu8, 0x9eu8, 0x03u8, - 0xd6u8, 0x26u8, 0x3fu8, 0xddu8, 0xebu8, 0xa4u8, 0x46u8, 0x2au8, - 0xf5u8, 0xb7u8, 0x17u8, 0xddu8, 0x11u8, 0xe4u8, 0xbeu8, 0xf4u8]) + store([0xb4u8, 0xb2u8, 0x6cu8, 0x2eu8, 0x29u8, 0x93u8, 0x1cu8, 0x06u8, + 0xe8u8, 0x85u8, 0x91u8, 0x46u8, 0x13u8, 0xfau8, 0xffu8, 0x58u8, + 0x56u8, 0x13u8, 0x8eu8, 0x5cu8, 0xb0u8, 0x96u8, 0x20u8, 0xddu8, + 0xb6u8, 0x92u8, 0x1au8, 0x34u8, 0x2du8, 0xedu8, 0x89u8, 0x57u8]) } fn nat_dec_lt_addr() -> Addr { - store([0x42u8, 0x95u8, 0xc0u8, 0x71u8, 0xa9u8, 0x48u8, 0x5au8, 0xf2u8, - 0xd9u8, 0x98u8, 0xe3u8, 0x94u8, 0x7bu8, 0xe5u8, 0x98u8, 0x80u8, - 0x77u8, 0x53u8, 0x1fu8, 0x02u8, 0xbfu8, 0x09u8, 0x1bu8, 0x87u8, - 0x0du8, 0x53u8, 0xceu8, 0x58u8, 0x9du8, 0x4eu8, 0xf5u8, 0xb1u8]) + store([0xc0u8, 0x13u8, 0xc1u8, 0x53u8, 0xebu8, 0xf0u8, 0x20u8, 0x28u8, + 0xaeu8, 0xd2u8, 0x64u8, 0x33u8, 0x3cu8, 0x1eu8, 0x4cu8, 0x85u8, + 0x01u8, 0x7du8, 0x0bu8, 0x87u8, 0x02u8, 0x5du8, 0x75u8, 0x96u8, + 0xa9u8, 0x69u8, 0x71u8, 0xbbu8, 0x2bu8, 0x67u8, 0x92u8, 0x1du8]) } fn int_dec_eq_addr() -> Addr { - store([0x19u8, 0xe0u8, 0x1bu8, 0xc9u8, 0xa3u8, 0x26u8, 0x4bu8, 0x9bu8, - 0x8bu8, 0x94u8, 0x0cu8, 0xf1u8, 0x72u8, 0xa2u8, 0x09u8, 0xbbu8, - 0x77u8, 0x4au8, 0xd3u8, 0x6fu8, 0x64u8, 0x10u8, 0xfau8, 0x74u8, - 0x2fu8, 0x00u8, 0x48u8, 0x04u8, 0x68u8, 0x08u8, 0xc0u8, 0xb6u8]) + store([0x83u8, 0xfdu8, 0xe3u8, 0x8fu8, 0xaau8, 0x11u8, 0x64u8, 0x64u8, + 0x8eu8, 0x42u8, 0x27u8, 0x97u8, 0x5au8, 0xbfu8, 0x2eu8, 0x8cu8, + 0x26u8, 0x0du8, 0x7du8, 0x4eu8, 0xf1u8, 0xc9u8, 0x26u8, 0x76u8, + 0x21u8, 0x4fu8, 0xfeu8, 0x58u8, 0x26u8, 0xc2u8, 0x07u8, 0x5du8]) } fn int_dec_le_addr() -> Addr { - store([0x7eu8, 0x04u8, 0x8eu8, 0xf3u8, 0x03u8, 0xecu8, 0xdcu8, 0x83u8, - 0x64u8, 0x67u8, 0xcdu8, 0xd4u8, 0xd8u8, 0x92u8, 0xf7u8, 0xfeu8, - 0x26u8, 0xfbu8, 0xbdu8, 0x7bu8, 0x62u8, 0xaeu8, 0x1du8, 0x17u8, - 0x46u8, 0x54u8, 0x3fu8, 0x4eu8, 0x30u8, 0x98u8, 0xc6u8, 0xe1u8]) + store([0x38u8, 0xd6u8, 0x0fu8, 0xfau8, 0x07u8, 0xb5u8, 0x06u8, 0x78u8, + 0xd0u8, 0xc3u8, 0xbfu8, 0x0cu8, 0x06u8, 0xf8u8, 0x6cu8, 0xd7u8, + 0x96u8, 0x7bu8, 0x35u8, 0xe8u8, 0x7au8, 0xb0u8, 0x71u8, 0xbcu8, + 0x55u8, 0x89u8, 0x9fu8, 0xcbu8, 0xaeu8, 0xd4u8, 0x74u8, 0x4fu8]) } fn int_dec_lt_addr() -> Addr { - store([0x6cu8, 0xc2u8, 0xd6u8, 0x3du8, 0xa1u8, 0xfdu8, 0x07u8, 0xe2u8, - 0x53u8, 0x3fu8, 0xcbu8, 0x08u8, 0xcbu8, 0xb3u8, 0x8cu8, 0x2du8, - 0x67u8, 0xf7u8, 0x51u8, 0x2au8, 0x7eu8, 0xfdu8, 0x15u8, 0x23u8, - 0x6au8, 0x4bu8, 0x0eu8, 0x57u8, 0xbbu8, 0x1fu8, 0xcdu8, 0x53u8]) + store([0x55u8, 0x68u8, 0xe7u8, 0x99u8, 0x19u8, 0x8du8, 0xadu8, 0x9fu8, + 0xabu8, 0x0eu8, 0x78u8, 0x4bu8, 0x7au8, 0x4cu8, 0x58u8, 0x11u8, + 0x2bu8, 0xfcu8, 0x26u8, 0x88u8, 0xaeu8, 0xceu8, 0xbeu8, 0x3cu8, + 0x2cu8, 0x65u8, 0x63u8, 0x30u8, 0x42u8, 0x10u8, 0xf9u8, 0x56u8]) } fn int_of_nat_addr() -> Addr { - store([0x46u8, 0xb5u8, 0xebu8, 0x67u8, 0x68u8, 0xc1u8, 0xf4u8, 0x95u8, - 0x87u8, 0xd6u8, 0x53u8, 0xc1u8, 0x2eu8, 0x37u8, 0x33u8, 0x89u8, - 0x12u8, 0x15u8, 0x33u8, 0x86u8, 0x83u8, 0x2fu8, 0x0fu8, 0xd0u8, - 0xe4u8, 0x72u8, 0x48u8, 0x4eu8, 0x26u8, 0x32u8, 0x26u8, 0x32u8]) + store([0x09u8, 0xbcu8, 0x25u8, 0x31u8, 0x47u8, 0xc3u8, 0x6cu8, 0xe2u8, + 0x2cu8, 0x8eu8, 0x0cu8, 0xcdu8, 0x43u8, 0xc7u8, 0x9bu8, 0x2cu8, + 0xdau8, 0xe2u8, 0x20u8, 0x6eu8, 0x0du8, 0xddu8, 0x16u8, 0x8fu8, + 0xcau8, 0x36u8, 0x09u8, 0xb2u8, 0xa5u8, 0x84u8, 0xd3u8, 0xdcu8]) } fn int_neg_succ_addr() -> Addr { - store([0x25u8, 0xbbu8, 0xcdu8, 0x75u8, 0x6bu8, 0x52u8, 0xebu8, 0x78u8, - 0xbcu8, 0xe1u8, 0x70u8, 0x41u8, 0x0du8, 0xefu8, 0xa4u8, 0xc1u8, - 0x5bu8, 0x23u8, 0x8du8, 0xedu8, 0xefu8, 0x5fu8, 0x7bu8, 0x89u8, - 0x69u8, 0x16u8, 0x21u8, 0xdcu8, 0xbeu8, 0x91u8, 0x97u8, 0x80u8]) + store([0x26u8, 0x7cu8, 0x0au8, 0x9cu8, 0x92u8, 0xe7u8, 0x56u8, 0x38u8, + 0xfcu8, 0x73u8, 0xedu8, 0x52u8, 0xa9u8, 0xf9u8, 0xc8u8, 0x16u8, + 0x47u8, 0xeeu8, 0xecu8, 0xeeu8, 0xffu8, 0x21u8, 0x44u8, 0xc1u8, + 0xf9u8, 0x7eu8, 0x65u8, 0xe2u8, 0xafu8, 0xf1u8, 0x49u8, 0xf1u8]) } -- Address constants below registered in Rust primitive.rs but not wired @@ -194,143 +194,143 @@ def primitive := ⟦ -- Restore + plug if a reduction/canonicalization tier needs them. /- fn int_addr() -> Addr { - store([0xe7u8, 0xdcu8, 0x2du8, 0x5au8, 0x2eu8, 0x15u8, 0x3eu8, 0x1au8, - 0xb0u8, 0xc7u8, 0x87u8, 0x97u8, 0xbcu8, 0xbfu8, 0xd5u8, 0x3au8, - 0x2cu8, 0x01u8, 0xffu8, 0x40u8, 0x91u8, 0x88u8, 0x77u8, 0xcfu8, - 0xadu8, 0x8au8, 0xdeu8, 0x8cu8, 0x41u8, 0x69u8, 0xa4u8, 0x3au8]) + store([0xa5u8, 0xcau8, 0x2eu8, 0x1du8, 0x5cu8, 0xebu8, 0x8du8, 0x43u8, + 0x36u8, 0x7bu8, 0xc3u8, 0x4du8, 0x69u8, 0xa5u8, 0x0cu8, 0x16u8, + 0x50u8, 0xa2u8, 0x5du8, 0xc1u8, 0x07u8, 0x80u8, 0xaau8, 0x0cu8, + 0x37u8, 0x8cu8, 0xdfu8, 0xa9u8, 0x31u8, 0xffu8, 0x04u8, 0x24u8]) } fn int_add_addr() -> Addr { - store([0xd8u8, 0xe6u8, 0xcdu8, 0xc9u8, 0x88u8, 0xd4u8, 0x28u8, 0x8eu8, - 0x48u8, 0xccu8, 0x60u8, 0x92u8, 0x73u8, 0x0bu8, 0xc5u8, 0x38u8, - 0x71u8, 0x76u8, 0xcfu8, 0xf6u8, 0x59u8, 0x24u8, 0x71u8, 0xa3u8, - 0x28u8, 0xccu8, 0x43u8, 0x54u8, 0xf1u8, 0x87u8, 0x84u8, 0x12u8]) + store([0xcau8, 0x99u8, 0x08u8, 0x4cu8, 0x9du8, 0x2fu8, 0xcbu8, 0x4cu8, + 0x5du8, 0xd1u8, 0x39u8, 0xaeu8, 0xcau8, 0xf1u8, 0x59u8, 0xebu8, + 0xd0u8, 0x49u8, 0x92u8, 0xd7u8, 0x62u8, 0x30u8, 0xcbu8, 0x93u8, + 0x0fu8, 0x41u8, 0xb8u8, 0x60u8, 0x74u8, 0x68u8, 0x48u8, 0x17u8]) } fn int_sub_addr() -> Addr { - store([0x93u8, 0xb2u8, 0xd1u8, 0x2du8, 0x77u8, 0x97u8, 0xfdu8, 0x62u8, - 0xc2u8, 0x0bu8, 0xecu8, 0x25u8, 0x53u8, 0x36u8, 0xc1u8, 0xe9u8, - 0x1cu8, 0xa1u8, 0xceu8, 0xf7u8, 0xa6u8, 0x95u8, 0x10u8, 0x71u8, - 0x29u8, 0x6fu8, 0xc1u8, 0xabu8, 0x5bu8, 0xd1u8, 0xd8u8, 0xc8u8]) + store([0xd3u8, 0x14u8, 0x12u8, 0x31u8, 0x80u8, 0x0eu8, 0x01u8, 0x2eu8, + 0x8du8, 0xb7u8, 0xc2u8, 0x40u8, 0xf7u8, 0x94u8, 0xe4u8, 0x92u8, + 0x9bu8, 0xfdu8, 0x15u8, 0x6bu8, 0x38u8, 0x45u8, 0xe2u8, 0x2fu8, + 0x1cu8, 0xf3u8, 0x1du8, 0x3fu8, 0xe3u8, 0x9au8, 0xecu8, 0xd9u8]) } fn int_mul_addr() -> Addr { - store([0x9au8, 0xd6u8, 0xeeu8, 0x18u8, 0xefu8, 0x6du8, 0x7du8, 0x74u8, - 0xbbu8, 0xe4u8, 0x49u8, 0xabu8, 0x61u8, 0xaau8, 0x31u8, 0xf8u8, - 0x4au8, 0x0eu8, 0x78u8, 0x95u8, 0x1eu8, 0x95u8, 0x60u8, 0xd2u8, - 0x8fu8, 0xd8u8, 0x2eu8, 0x0cu8, 0x3bu8, 0x07u8, 0x1du8, 0x01u8]) + store([0x48u8, 0x20u8, 0x64u8, 0xe3u8, 0x56u8, 0x34u8, 0xa9u8, 0x5cu8, + 0x0fu8, 0x25u8, 0x2du8, 0xe7u8, 0x3du8, 0x68u8, 0x7cu8, 0x24u8, + 0x76u8, 0x4eu8, 0xa4u8, 0xfau8, 0x7du8, 0xfdu8, 0x14u8, 0xcfu8, + 0x7au8, 0xf8u8, 0xaau8, 0x75u8, 0x31u8, 0xf1u8, 0x7au8, 0x5cu8]) } fn int_neg_addr() -> Addr { - store([0x8cu8, 0x3fu8, 0x64u8, 0xe6u8, 0xb5u8, 0xbau8, 0xaau8, 0xa1u8, - 0x25u8, 0xf0u8, 0x63u8, 0x7du8, 0x7au8, 0x82u8, 0x4du8, 0xf6u8, - 0x27u8, 0xdbu8, 0xedu8, 0xe0u8, 0x11u8, 0x59u8, 0x68u8, 0xf3u8, - 0xc8u8, 0x0cu8, 0x55u8, 0xe0u8, 0x22u8, 0x55u8, 0x44u8, 0x62u8]) + store([0xf6u8, 0x1cu8, 0x7du8, 0x3fu8, 0xceu8, 0x59u8, 0x54u8, 0x30u8, + 0xf8u8, 0x6fu8, 0x0cu8, 0xd5u8, 0x2du8, 0xa5u8, 0xbcu8, 0xb0u8, + 0x0bu8, 0xf9u8, 0x10u8, 0xedu8, 0xd8u8, 0x5eu8, 0x14u8, 0xdcu8, + 0x04u8, 0x02u8, 0x13u8, 0x0fu8, 0xccu8, 0xe3u8, 0x4eu8, 0xbdu8]) } fn int_emod_addr() -> Addr { - store([0x7cu8, 0xdbu8, 0x11u8, 0x27u8, 0x25u8, 0xd3u8, 0xa4u8, 0xf5u8, - 0x42u8, 0xbfu8, 0xb0u8, 0xcdu8, 0x30u8, 0x92u8, 0x68u8, 0x64u8, - 0x1bu8, 0xd8u8, 0x9du8, 0xdcu8, 0x98u8, 0x90u8, 0xc7u8, 0x22u8, - 0x1eu8, 0xd0u8, 0x1fu8, 0x99u8, 0xb6u8, 0xa0u8, 0x0bu8, 0x63u8]) + store([0x25u8, 0xc2u8, 0x67u8, 0xefu8, 0x44u8, 0xf1u8, 0x50u8, 0x07u8, + 0xf2u8, 0xd2u8, 0xe0u8, 0x81u8, 0x9bu8, 0xe6u8, 0xfbu8, 0x64u8, + 0x90u8, 0x2cu8, 0x33u8, 0xa7u8, 0xd2u8, 0x7au8, 0x6fu8, 0x2cu8, + 0x9du8, 0x61u8, 0x26u8, 0x38u8, 0x98u8, 0x95u8, 0x38u8, 0x04u8]) } fn int_ediv_addr() -> Addr { - store([0xbau8, 0x19u8, 0x4cu8, 0x0au8, 0x36u8, 0x74u8, 0xe6u8, 0x7bu8, - 0x99u8, 0x68u8, 0xd0u8, 0xa6u8, 0x5cu8, 0xddu8, 0xa3u8, 0xa4u8, - 0xddu8, 0xb9u8, 0xdcu8, 0xdcu8, 0xe4u8, 0x8au8, 0xd6u8, 0xc6u8, - 0x2eu8, 0x91u8, 0xd4u8, 0x78u8, 0xa1u8, 0x0au8, 0x3du8, 0xddu8]) + store([0x49u8, 0xb3u8, 0x4du8, 0xcbu8, 0xffu8, 0x1eu8, 0x60u8, 0x53u8, + 0x28u8, 0x25u8, 0xffu8, 0x5au8, 0xf4u8, 0x77u8, 0xebu8, 0x5du8, + 0xe9u8, 0x81u8, 0x0eu8, 0xe3u8, 0x8eu8, 0x0fu8, 0x7au8, 0x32u8, + 0x01u8, 0x4du8, 0x54u8, 0xc8u8, 0xc1u8, 0xa3u8, 0xa3u8, 0xc5u8]) } fn int_bmod_addr() -> Addr { - store([0xc8u8, 0x43u8, 0x1bu8, 0x7au8, 0xdbu8, 0x91u8, 0x89u8, 0x67u8, - 0xaau8, 0x05u8, 0xbau8, 0x6fu8, 0xd8u8, 0x29u8, 0x7fu8, 0x33u8, - 0xe9u8, 0x7du8, 0x67u8, 0x00u8, 0x3eu8, 0x41u8, 0x38u8, 0x02u8, - 0x1du8, 0x91u8, 0x2eu8, 0xa9u8, 0x2cu8, 0xc1u8, 0x88u8, 0x7fu8]) + store([0x6au8, 0x6au8, 0xdfu8, 0x0eu8, 0x95u8, 0xb3u8, 0xa4u8, 0xceu8, + 0x18u8, 0x33u8, 0x0eu8, 0xe2u8, 0x21u8, 0x05u8, 0x71u8, 0x2eu8, + 0x9au8, 0x64u8, 0x0eu8, 0xe4u8, 0x31u8, 0x1bu8, 0x5du8, 0xd1u8, + 0x02u8, 0x2au8, 0x8eu8, 0x0au8, 0x30u8, 0xcbu8, 0xa0u8, 0xafu8]) } fn int_bdiv_addr() -> Addr { - store([0xabu8, 0x72u8, 0x47u8, 0x72u8, 0x54u8, 0xd1u8, 0xcau8, 0x47u8, - 0x38u8, 0x12u8, 0x3au8, 0xd6u8, 0x12u8, 0xeau8, 0xe4u8, 0xdfu8, - 0xb9u8, 0x12u8, 0x6eu8, 0xf7u8, 0x83u8, 0x10u8, 0xedu8, 0x7du8, - 0x2eu8, 0xbdu8, 0xe8u8, 0x10u8, 0x09u8, 0x63u8, 0xbfu8, 0xb1u8]) + store([0xa4u8, 0xf1u8, 0xd7u8, 0xa3u8, 0xfeu8, 0x5bu8, 0x6bu8, 0x2eu8, + 0xf9u8, 0x52u8, 0x2fu8, 0xa5u8, 0x37u8, 0xf1u8, 0xe6u8, 0x22u8, + 0xfbu8, 0xb8u8, 0x17u8, 0x6fu8, 0x9fu8, 0xb3u8, 0x35u8, 0x8cu8, + 0x56u8, 0xceu8, 0xbeu8, 0x1au8, 0x37u8, 0x9bu8, 0x61u8, 0x84u8]) } fn int_nat_abs_addr() -> Addr { - store([0x60u8, 0x66u8, 0x2eu8, 0x33u8, 0x22u8, 0x4fu8, 0x55u8, 0xbeu8, - 0x9eu8, 0x36u8, 0x76u8, 0x83u8, 0x37u8, 0x8cu8, 0x7bu8, 0xf6u8, - 0x09u8, 0x3cu8, 0x12u8, 0x5cu8, 0x04u8, 0xffu8, 0x7cu8, 0x4eu8, - 0x3eu8, 0xcau8, 0x37u8, 0x01u8, 0x12u8, 0xe1u8, 0xc5u8, 0x62u8]) + store([0x83u8, 0xe3u8, 0xceu8, 0x8au8, 0x74u8, 0x75u8, 0x20u8, 0xccu8, + 0x24u8, 0x8au8, 0x0du8, 0xacu8, 0xf9u8, 0xbdu8, 0x13u8, 0x69u8, + 0x46u8, 0x7eu8, 0x49u8, 0x07u8, 0xe8u8, 0xaau8, 0xaau8, 0x43u8, + 0x3eu8, 0x1bu8, 0x43u8, 0x8eu8, 0x1cu8, 0xadu8, 0x7cu8, 0xa4u8]) } fn int_pow_addr() -> Addr { - store([0x0du8, 0xfeu8, 0x8fu8, 0x22u8, 0xbdu8, 0x6cu8, 0xb6u8, 0x7du8, - 0x53u8, 0x8au8, 0x2fu8, 0x01u8, 0x8fu8, 0x0eu8, 0x40u8, 0x6fu8, - 0xc0u8, 0xb5u8, 0xd7u8, 0x30u8, 0xcau8, 0xa6u8, 0x3eu8, 0x1au8, - 0x79u8, 0x8du8, 0xfau8, 0x9au8, 0xd7u8, 0x8bu8, 0xabu8, 0x07u8]) + store([0x73u8, 0xecu8, 0xccu8, 0xfeu8, 0xabu8, 0x8au8, 0x63u8, 0xa3u8, + 0xa0u8, 0xfau8, 0xf8u8, 0xd7u8, 0x1du8, 0xc7u8, 0x79u8, 0x95u8, + 0xbdu8, 0xa8u8, 0x34u8, 0x18u8, 0xb1u8, 0x3cu8, 0xd3u8, 0x99u8, + 0xb1u8, 0xfau8, 0x57u8, 0x1bu8, 0x50u8, 0xb4u8, 0x57u8, 0x5eu8]) } fn bool_no_confusion_addr() -> Addr { - store([0x5bu8, 0x94u8, 0x71u8, 0x83u8, 0x22u8, 0xc6u8, 0x33u8, 0xadu8, - 0x16u8, 0x35u8, 0x92u8, 0xdbu8, 0x4fu8, 0xb7u8, 0x43u8, 0x23u8, - 0x60u8, 0xf5u8, 0xd0u8, 0x23u8, 0xadu8, 0xfau8, 0x77u8, 0x49u8, - 0xf5u8, 0xcfu8, 0x51u8, 0x75u8, 0x79u8, 0x8du8, 0x16u8, 0xcau8]) + store([0xcdu8, 0x98u8, 0x3au8, 0x82u8, 0x6cu8, 0x1eu8, 0x20u8, 0xc4u8, + 0x57u8, 0x0au8, 0xfcu8, 0xa2u8, 0x44u8, 0x91u8, 0x6cu8, 0x79u8, + 0xe2u8, 0x0eu8, 0x81u8, 0x6fu8, 0x61u8, 0x8fu8, 0xfdu8, 0xdau8, + 0x38u8, 0xbeu8, 0x8au8, 0x79u8, 0x07u8, 0x92u8, 0x74u8, 0xceu8]) } fn char_mk_addr() -> Addr { - store([0x31u8, 0x6fu8, 0xe9u8, 0x1eu8, 0xdeu8, 0x33u8, 0x07u8, 0x9fu8, - 0x23u8, 0x30u8, 0xccu8, 0x99u8, 0x21u8, 0xeeu8, 0x11u8, 0x7fu8, - 0x9au8, 0xcau8, 0x02u8, 0x3eu8, 0xfau8, 0x14u8, 0xf5u8, 0xb1u8, - 0xfeu8, 0x02u8, 0x4du8, 0xdbu8, 0xe6u8, 0x25u8, 0xfeu8, 0x86u8]) + store([0x97u8, 0xafu8, 0xa5u8, 0xadu8, 0x3du8, 0x86u8, 0x89u8, 0x5eu8, + 0x6du8, 0x15u8, 0x50u8, 0x19u8, 0xb6u8, 0x6cu8, 0x25u8, 0x6cu8, + 0xd1u8, 0xaau8, 0x86u8, 0x2bu8, 0x4eu8, 0x3cu8, 0x89u8, 0xd8u8, + 0xc6u8, 0x58u8, 0x0bu8, 0x61u8, 0x93u8, 0x9eu8, 0xe5u8, 0x41u8]) } fn nat_bitwise_addr() -> Addr { - store([0x0bu8, 0x69u8, 0xfbu8, 0xfbu8, 0x2eu8, 0xf3u8, 0xc7u8, 0x73u8, - 0x3au8, 0xd2u8, 0xf6u8, 0xbdu8, 0x77u8, 0x07u8, 0x82u8, 0x0cu8, - 0x32u8, 0x60u8, 0x3au8, 0x79u8, 0x60u8, 0x35u8, 0x01u8, 0xa7u8, - 0x7fu8, 0xbbu8, 0xefu8, 0x74u8, 0xdfu8, 0x85u8, 0x5au8, 0x32u8]) + store([0xd2u8, 0x07u8, 0x5eu8, 0x32u8, 0x3bu8, 0xedu8, 0x82u8, 0xf2u8, + 0x3eu8, 0xafu8, 0x75u8, 0xebu8, 0xc0u8, 0xfau8, 0xe4u8, 0xceu8, + 0xb8u8, 0x07u8, 0x94u8, 0x24u8, 0x0cu8, 0x04u8, 0x6bu8, 0x90u8, + 0xc5u8, 0x1au8, 0x94u8, 0xd0u8, 0x7fu8, 0x5eu8, 0x88u8, 0x5fu8]) } fn nat_rec_addr() -> Addr { - store([0x43u8, 0x61u8, 0x95u8, 0x10u8, 0xeeu8, 0x8au8, 0x58u8, 0x3du8, - 0xb7u8, 0x2bu8, 0x9du8, 0x71u8, 0xb8u8, 0x4eu8, 0x7eu8, 0xa1u8, - 0x3au8, 0x19u8, 0x8fu8, 0xe3u8, 0x3du8, 0x73u8, 0x96u8, 0x3cu8, - 0xf0u8, 0xccu8, 0x1eu8, 0xbfu8, 0x68u8, 0xa6u8, 0x8au8, 0xd6u8]) + store([0xb9u8, 0x75u8, 0x15u8, 0x2fu8, 0x3fu8, 0x0cu8, 0xd9u8, 0x03u8, + 0x94u8, 0x33u8, 0xc6u8, 0x8fu8, 0x5au8, 0x5eu8, 0x54u8, 0x55u8, + 0xf5u8, 0xcbu8, 0x5du8, 0x91u8, 0x70u8, 0x78u8, 0xbau8, 0xedu8, + 0x01u8, 0x18u8, 0xb5u8, 0x90u8, 0x67u8, 0xa7u8, 0x4eu8, 0xa7u8]) } fn nat_cases_on_addr() -> Addr { - store([0x28u8, 0x09u8, 0x6du8, 0x7cu8, 0xa6u8, 0xb3u8, 0xf9u8, 0x6bu8, - 0xd2u8, 0x50u8, 0xccu8, 0x8bu8, 0x8fu8, 0xeeu8, 0x00u8, 0xc3u8, - 0x6bu8, 0xbcu8, 0x36u8, 0xddu8, 0x1du8, 0xd2u8, 0x04u8, 0x08u8, - 0x54u8, 0x04u8, 0x1eu8, 0xc1u8, 0x39u8, 0x93u8, 0xbau8, 0x34u8]) + store([0x19u8, 0x17u8, 0x84u8, 0x1du8, 0x20u8, 0x85u8, 0x79u8, 0x6du8, + 0xd7u8, 0xbau8, 0x34u8, 0x6du8, 0xe9u8, 0x3au8, 0x57u8, 0x95u8, + 0x71u8, 0xb5u8, 0x64u8, 0x1cu8, 0x33u8, 0xfcu8, 0x40u8, 0x04u8, + 0x08u8, 0xecu8, 0x55u8, 0xb5u8, 0x77u8, 0x8au8, 0x9au8, 0x51u8]) } fn list_addr() -> Addr { - store([0xabu8, 0xedu8, 0x9fu8, 0xf1u8, 0xabu8, 0xa4u8, 0x63u8, 0x4au8, - 0xbcu8, 0x0bu8, 0xd3u8, 0xafu8, 0x76u8, 0xcau8, 0x54u8, 0x42u8, - 0x85u8, 0xa3u8, 0x2du8, 0xcfu8, 0xe4u8, 0x3du8, 0xc2u8, 0x7bu8, - 0x12u8, 0x9au8, 0xeau8, 0x88u8, 0x67u8, 0x45u8, 0x76u8, 0x20u8]) + store([0x14u8, 0x4eu8, 0x20u8, 0x7au8, 0x88u8, 0xd1u8, 0xdfu8, 0xbdu8, + 0xe2u8, 0x2au8, 0x1bu8, 0x40u8, 0x68u8, 0x90u8, 0x33u8, 0xb3u8, + 0xa6u8, 0x5au8, 0x65u8, 0x2cu8, 0x8fu8, 0x75u8, 0x00u8, 0xb9u8, + 0xbeu8, 0x3cu8, 0xb7u8, 0xf6u8, 0x63u8, 0x66u8, 0xe0u8, 0xfeu8]) } fn string_addr() -> Addr { - store([0x42u8, 0x26u8, 0x58u8, 0xd0u8, 0x43u8, 0xeeu8, 0x48u8, 0x2fu8, - 0x71u8, 0x02u8, 0xd2u8, 0xf6u8, 0xeau8, 0x65u8, 0x96u8, 0x66u8, - 0x48u8, 0x08u8, 0xe8u8, 0x99u8, 0xabu8, 0xadu8, 0x62u8, 0x80u8, - 0x80u8, 0x47u8, 0x8au8, 0x1eu8, 0x91u8, 0x89u8, 0xf0u8, 0xaau8]) + store([0x7au8, 0xb2u8, 0xd5u8, 0x2au8, 0xc5u8, 0x2fu8, 0xd1u8, 0xf5u8, + 0x18u8, 0x09u8, 0xb7u8, 0x18u8, 0xe5u8, 0x3cu8, 0xd0u8, 0x58u8, + 0xacu8, 0x4bu8, 0x50u8, 0xd6u8, 0x51u8, 0x50u8, 0xe7u8, 0x8au8, + 0xe6u8, 0x19u8, 0x13u8, 0x9cu8, 0xcfu8, 0x13u8, 0xc8u8, 0xfdu8]) } fn string_mk_addr() -> Addr { - store([0x40u8, 0x5du8, 0x36u8, 0xf5u8, 0xf6u8, 0x47u8, 0x9cu8, 0x40u8, - 0x21u8, 0x6fu8, 0xf7u8, 0xbbu8, 0xbau8, 0x10u8, 0xb0u8, 0x77u8, - 0x84u8, 0x8eu8, 0xc3u8, 0x3au8, 0xf0u8, 0x3eu8, 0xf4u8, 0x04u8, - 0x0bu8, 0xfau8, 0x4fu8, 0x82u8, 0x93u8, 0x0du8, 0xe4u8, 0xbau8]) + store([0x96u8, 0x71u8, 0xfdu8, 0x4fu8, 0xcfu8, 0xbcu8, 0x06u8, 0x1cu8, + 0x93u8, 0xc2u8, 0x82u8, 0x48u8, 0x64u8, 0xcfu8, 0x03u8, 0x12u8, + 0x4fu8, 0xfeu8, 0xe7u8, 0xccu8, 0x22u8, 0x30u8, 0x8du8, 0xe1u8, + 0x2au8, 0x7cu8, 0x82u8, 0x64u8, 0x73u8, 0xe4u8, 0x99u8, 0x06u8]) } fn of_nat_of_nat_addr() -> Addr { - store([0x8fu8, 0xdcu8, 0x86u8, 0x9fu8, 0x7bu8, 0x7au8, 0xa2u8, 0xb7u8, - 0xb5u8, 0x92u8, 0x9bu8, 0xa2u8, 0x42u8, 0xedu8, 0x89u8, 0x9cu8, - 0xe2u8, 0xd7u8, 0xc5u8, 0xd4u8, 0x2du8, 0xf1u8, 0xd4u8, 0xe2u8, - 0x39u8, 0x36u8, 0x90u8, 0xcfu8, 0xa8u8, 0x5eu8, 0x94u8, 0xd2u8]) + store([0x5au8, 0x72u8, 0x92u8, 0xadu8, 0x75u8, 0x6eu8, 0xe1u8, 0xf2u8, + 0xdfu8, 0x4bu8, 0x92u8, 0xf1u8, 0x8au8, 0x27u8, 0x57u8, 0x4au8, + 0x47u8, 0xcbu8, 0xbcu8, 0xf7u8, 0x09u8, 0x4fu8, 0x98u8, 0xabu8, + 0x28u8, 0x65u8, 0xf9u8, 0x2eu8, 0xb2u8, 0x23u8, 0x42u8, 0xd7u8]) } fn eager_reduce_addr() -> Addr { @@ -340,354 +340,354 @@ def primitive := ⟦ } fn pprod_addr() -> Addr { - store([0x6eu8, 0x99u8, 0xb0u8, 0x86u8, 0x70u8, 0x0fu8, 0x29u8, 0x01u8, - 0x80u8, 0x4au8, 0x10u8, 0x7cu8, 0xadu8, 0x5eu8, 0xf0u8, 0xfeu8, - 0x87u8, 0x80u8, 0x77u8, 0xb1u8, 0x72u8, 0x3fu8, 0x4bu8, 0x82u8, - 0x46u8, 0x15u8, 0xddu8, 0x02u8, 0x1du8, 0x4du8, 0x51u8, 0x57u8]) + store([0x81u8, 0xa4u8, 0x22u8, 0xa4u8, 0x2bu8, 0x2cu8, 0xb6u8, 0x56u8, + 0xb9u8, 0xa4u8, 0x7eu8, 0x61u8, 0xa4u8, 0x42u8, 0x2fu8, 0x89u8, + 0xcdu8, 0xb0u8, 0xa0u8, 0xc1u8, 0x66u8, 0x03u8, 0x5du8, 0x47u8, + 0xbfu8, 0x5eu8, 0x2cu8, 0x2au8, 0xf0u8, 0x21u8, 0x75u8, 0xfau8]) } fn pprod_mk_addr() -> Addr { - store([0x00u8, 0xddu8, 0xf2u8, 0x6eu8, 0xfdu8, 0x5fu8, 0x7eu8, 0x5eu8, - 0xeeu8, 0x55u8, 0x61u8, 0xc2u8, 0x46u8, 0x7bu8, 0x16u8, 0xacu8, - 0x85u8, 0x6eu8, 0xfcu8, 0xb3u8, 0xa1u8, 0x22u8, 0x65u8, 0x44u8, - 0x48u8, 0x76u8, 0x45u8, 0xddu8, 0x46u8, 0x20u8, 0x85u8, 0x96u8]) + store([0xc9u8, 0xc5u8, 0x84u8, 0xdau8, 0x78u8, 0x2cu8, 0xdcu8, 0x45u8, + 0x33u8, 0x06u8, 0xbeu8, 0x9au8, 0x64u8, 0x32u8, 0x44u8, 0xfau8, + 0x0bu8, 0xcbu8, 0xfcu8, 0x3bu8, 0x5du8, 0xbcu8, 0xbau8, 0xfeu8, + 0x3fu8, 0x6bu8, 0x9du8, 0x65u8, 0xdfu8, 0x03u8, 0x1fu8, 0xedu8]) } -/ fn fin_addr() -> Addr { - store([0x27u8, 0x2au8, 0xa9u8, 0xe1u8, 0x6cu8, 0x03u8, 0xe9u8, 0xadu8, - 0x73u8, 0x37u8, 0xe7u8, 0x06u8, 0xd7u8, 0x3eu8, 0xfdu8, 0x14u8, - 0xccu8, 0xf1u8, 0xdau8, 0x10u8, 0xe2u8, 0xf8u8, 0x36u8, 0x7du8, - 0xd3u8, 0x43u8, 0x74u8, 0xb6u8, 0x0eu8, 0x15u8, 0x56u8, 0xfau8]) + store([0x74u8, 0x59u8, 0x36u8, 0xfcu8, 0xb9u8, 0xd8u8, 0x6cu8, 0x44u8, + 0x57u8, 0xf0u8, 0xfdu8, 0x1eu8, 0x53u8, 0x7eu8, 0x67u8, 0x07u8, + 0x7fu8, 0x46u8, 0xf7u8, 0x84u8, 0x11u8, 0x08u8, 0x41u8, 0x9du8, + 0xacu8, 0x79u8, 0x84u8, 0x00u8, 0x8bu8, 0x56u8, 0x5bu8, 0x97u8]) } fn decidable_rec_addr() -> Addr { - store([0x7au8, 0x18u8, 0xcau8, 0x84u8, 0xa1u8, 0x13u8, 0xb0u8, 0xc2u8, - 0xadu8, 0x0cu8, 0xc0u8, 0xe8u8, 0x25u8, 0xa5u8, 0x5du8, 0x76u8, - 0x7eu8, 0x77u8, 0xa8u8, 0x9eu8, 0x8du8, 0x0eu8, 0x1du8, 0x82u8, - 0xebu8, 0x91u8, 0x04u8, 0x85u8, 0x9fu8, 0x53u8, 0xd0u8, 0x95u8]) + store([0xabu8, 0x37u8, 0x76u8, 0x98u8, 0x57u8, 0x43u8, 0xafu8, 0x13u8, + 0xa9u8, 0xcbu8, 0x1au8, 0x7du8, 0x2fu8, 0x84u8, 0x96u8, 0x99u8, + 0x78u8, 0x92u8, 0xe1u8, 0x79u8, 0x83u8, 0xd1u8, 0x4bu8, 0xe5u8, + 0x27u8, 0x0au8, 0x71u8, 0x65u8, 0x70u8, 0xb3u8, 0x57u8, 0x19u8]) } fn decidable_is_true_addr() -> Addr { - store([0x3au8, 0xe2u8, 0xc7u8, 0x1du8, 0xa2u8, 0xbfu8, 0x34u8, 0x17u8, - 0x9au8, 0x5au8, 0x88u8, 0x08u8, 0x85u8, 0x7cu8, 0x34u8, 0xa3u8, - 0xb7u8, 0x66u8, 0x2fu8, 0xf5u8, 0x65u8, 0x4du8, 0x8cu8, 0x24u8, - 0x7cu8, 0x43u8, 0xe8u8, 0x5au8, 0x7cu8, 0xdeu8, 0x49u8, 0x3fu8]) + store([0x0fu8, 0x9eu8, 0xe8u8, 0xd9u8, 0x03u8, 0x3du8, 0x8fu8, 0x7bu8, + 0x85u8, 0x2fu8, 0x5bu8, 0x71u8, 0x52u8, 0xfdu8, 0x12u8, 0x4fu8, + 0x7du8, 0x41u8, 0x19u8, 0x30u8, 0xc9u8, 0x92u8, 0xe0u8, 0xf4u8, + 0x57u8, 0xf8u8, 0x10u8, 0x4bu8, 0x60u8, 0xa9u8, 0x83u8, 0x81u8]) } fn decidable_is_false_addr() -> Addr { - store([0x10u8, 0xacu8, 0x5fu8, 0x48u8, 0x79u8, 0x8bu8, 0x3fu8, 0xf0u8, - 0x1bu8, 0x0fu8, 0x74u8, 0xc0u8, 0xb5u8, 0x44u8, 0xd2u8, 0x27u8, - 0x96u8, 0xc9u8, 0x77u8, 0x5fu8, 0x6du8, 0x43u8, 0xd3u8, 0x28u8, - 0x31u8, 0x6bu8, 0xbbu8, 0x3au8, 0xa1u8, 0x63u8, 0x89u8, 0x99u8]) + store([0x04u8, 0x71u8, 0xe4u8, 0x71u8, 0x58u8, 0xb2u8, 0xaeu8, 0x18u8, + 0xd3u8, 0xc0u8, 0x8du8, 0xd5u8, 0xc7u8, 0x7au8, 0xaeu8, 0x23u8, + 0xe6u8, 0x2du8, 0x7bu8, 0xbcu8, 0x1eu8, 0x61u8, 0x11u8, 0x6bu8, + 0xc2u8, 0x81u8, 0x3bu8, 0x13u8, 0x06u8, 0xbcu8, 0x57u8, 0x95u8]) } fn nat_le_of_ble_eq_true_addr() -> Addr { - store([0xbau8, 0xb3u8, 0x7au8, 0x8bu8, 0xd9u8, 0x86u8, 0x0du8, 0x3bu8, - 0xfeu8, 0x31u8, 0xf1u8, 0xa1u8, 0x75u8, 0x2fu8, 0xe7u8, 0x00u8, - 0x8au8, 0x22u8, 0x4cu8, 0x6au8, 0xd8u8, 0xafu8, 0x62u8, 0x3cu8, - 0x7fu8, 0xb8u8, 0xbdu8, 0x19u8, 0x2bu8, 0xe5u8, 0xc0u8, 0x7eu8]) + store([0x21u8, 0xe0u8, 0xe0u8, 0x78u8, 0x3bu8, 0x76u8, 0x17u8, 0xb0u8, + 0xccu8, 0x4eu8, 0xffu8, 0x4du8, 0x1fu8, 0xabu8, 0x7cu8, 0xffu8, + 0xefu8, 0xe0u8, 0x1cu8, 0xd4u8, 0x3du8, 0xa7u8, 0x7eu8, 0x2fu8, + 0x98u8, 0xd1u8, 0x50u8, 0x94u8, 0xa0u8, 0xd8u8, 0xf0u8, 0x86u8]) } fn nat_not_le_of_not_ble_eq_true_addr() -> Addr { - store([0x98u8, 0x1bu8, 0x00u8, 0xb7u8, 0xc4u8, 0x58u8, 0x99u8, 0xf7u8, - 0x26u8, 0xc3u8, 0xdeu8, 0x35u8, 0x32u8, 0x80u8, 0x74u8, 0xcbu8, - 0x3fu8, 0x72u8, 0xa0u8, 0x92u8, 0x25u8, 0x74u8, 0x3du8, 0xa8u8, - 0x1fu8, 0x50u8, 0x31u8, 0xffu8, 0x6eu8, 0x64u8, 0x7bu8, 0xa9u8]) + store([0x01u8, 0x83u8, 0x59u8, 0x5bu8, 0x83u8, 0x7bu8, 0x9bu8, 0x84u8, + 0xdau8, 0x5fu8, 0x00u8, 0x4bu8, 0x8au8, 0xc4u8, 0xa4u8, 0xbbu8, + 0xd3u8, 0xbcu8, 0x06u8, 0x28u8, 0xb9u8, 0x9cu8, 0x8du8, 0x55u8, + 0x0eu8, 0xb3u8, 0x51u8, 0xf7u8, 0x4cu8, 0xe1u8, 0x6du8, 0x48u8]) } fn nat_eq_of_beq_eq_true_addr() -> Addr { - store([0xa5u8, 0x7bu8, 0x81u8, 0x80u8, 0x28u8, 0x87u8, 0x01u8, 0xceu8, - 0xbfu8, 0xb1u8, 0xd6u8, 0xddu8, 0x29u8, 0xf1u8, 0x60u8, 0xccu8, - 0x4au8, 0xccu8, 0x3cu8, 0x6au8, 0xbau8, 0x98u8, 0x34u8, 0xe4u8, - 0x6bu8, 0x65u8, 0xf1u8, 0xc5u8, 0xaau8, 0x72u8, 0x17u8, 0xe2u8]) + store([0x9cu8, 0xe6u8, 0xe3u8, 0x22u8, 0xf1u8, 0x94u8, 0x81u8, 0xf2u8, + 0x1cu8, 0xf4u8, 0xc4u8, 0x8fu8, 0x88u8, 0x78u8, 0x98u8, 0x76u8, + 0xb6u8, 0x9bu8, 0x8au8, 0x9bu8, 0x15u8, 0x20u8, 0x43u8, 0x9cu8, + 0x10u8, 0x1du8, 0x98u8, 0x3fu8, 0x96u8, 0xeau8, 0x60u8, 0xb7u8]) } fn nat_ne_of_beq_eq_false_addr() -> Addr { - store([0x6eu8, 0x9bu8, 0x3cu8, 0x1cu8, 0xa5u8, 0xd9u8, 0xf0u8, 0x9bu8, - 0x90u8, 0x23u8, 0x21u8, 0xb1u8, 0x55u8, 0xedu8, 0xf4u8, 0x52u8, - 0x4cu8, 0x3eu8, 0x32u8, 0xdeu8, 0x1du8, 0x69u8, 0x0du8, 0xb9u8, - 0x17u8, 0xbfu8, 0xbau8, 0xaau8, 0xacu8, 0x3fu8, 0x8fu8, 0x82u8]) + store([0x3cu8, 0xf5u8, 0x4du8, 0x33u8, 0x38u8, 0x21u8, 0xddu8, 0x37u8, + 0x68u8, 0x3au8, 0x0bu8, 0xf3u8, 0x87u8, 0x39u8, 0xe6u8, 0x87u8, + 0x61u8, 0x0au8, 0x19u8, 0x91u8, 0x75u8, 0x92u8, 0x20u8, 0xb7u8, + 0x7eu8, 0xdeu8, 0xc3u8, 0x38u8, 0xbau8, 0x3cu8, 0xfbu8, 0xc8u8]) } fn reduce_bool_addr() -> Addr { - store([0x6eu8, 0x45u8, 0x3au8, 0x7cu8, 0xedu8, 0xafu8, 0xe2u8, 0xedu8, - 0xbbu8, 0xc1u8, 0xf0u8, 0x50u8, 0x34u8, 0x42u8, 0xbeu8, 0x49u8, - 0x9eu8, 0x4cu8, 0xbfu8, 0x18u8, 0xa6u8, 0xc0u8, 0x0du8, 0xc9u8, - 0x9fu8, 0x39u8, 0x03u8, 0xeeu8, 0x7fu8, 0x05u8, 0xdbu8, 0xafu8]) + store([0x1cu8, 0x17u8, 0x00u8, 0x98u8, 0xe2u8, 0x31u8, 0x43u8, 0xfdu8, + 0x8fu8, 0xd6u8, 0x17u8, 0x2cu8, 0xefu8, 0xd2u8, 0xecu8, 0xeeu8, + 0x30u8, 0x50u8, 0x72u8, 0xd2u8, 0x99u8, 0x11u8, 0x13u8, 0xcfu8, + 0xc4u8, 0xd5u8, 0x28u8, 0x40u8, 0xa5u8, 0xa9u8, 0xfau8, 0x78u8]) } fn reduce_nat_addr() -> Addr { - store([0x54u8, 0x19u8, 0x18u8, 0x7fu8, 0xbfu8, 0x67u8, 0xefu8, 0x1cu8, - 0x4fu8, 0xf9u8, 0xabu8, 0x0bu8, 0xe1u8, 0xb0u8, 0x1du8, 0x46u8, - 0x31u8, 0xa2u8, 0x70u8, 0x64u8, 0x7fu8, 0xfeu8, 0x43u8, 0x4bu8, - 0xf7u8, 0xe1u8, 0xf7u8, 0x88u8, 0xb3u8, 0xc8u8, 0x1du8, 0xd4u8]) + store([0x16u8, 0x85u8, 0x30u8, 0x76u8, 0xb0u8, 0xd9u8, 0x6du8, 0x35u8, + 0x6du8, 0x85u8, 0x48u8, 0x5cu8, 0x56u8, 0xf3u8, 0x39u8, 0x80u8, + 0x14u8, 0xb6u8, 0xa0u8, 0xf2u8, 0xeeu8, 0x72u8, 0xabu8, 0x16u8, + 0x28u8, 0x4au8, 0x38u8, 0x1du8, 0x9cu8, 0x28u8, 0xe5u8, 0x60u8]) } fn system_platform_num_bits_addr() -> Addr { - store([0xd4u8, 0x83u8, 0x96u8, 0x64u8, 0x38u8, 0xadu8, 0x47u8, 0xceu8, - 0x41u8, 0x55u8, 0xb3u8, 0x48u8, 0x58u8, 0x19u8, 0xa3u8, 0x77u8, - 0xe2u8, 0x26u8, 0x05u8, 0xb5u8, 0x9au8, 0x1au8, 0xafu8, 0xd0u8, - 0xb6u8, 0x81u8, 0xcbu8, 0x38u8, 0xacu8, 0xa8u8, 0x31u8, 0x07u8]) + store([0xcfu8, 0x86u8, 0x26u8, 0x35u8, 0x21u8, 0xd3u8, 0x45u8, 0xc3u8, + 0x90u8, 0x76u8, 0x47u8, 0x3eu8, 0xcdu8, 0xb9u8, 0xf6u8, 0xfdu8, + 0x41u8, 0x1bu8, 0x5bu8, 0x50u8, 0x3bu8, 0xceu8, 0x83u8, 0xe2u8, + 0x31u8, 0x8bu8, 0xa3u8, 0xfbu8, 0x6fu8, 0x23u8, 0x76u8, 0xd8u8]) } fn system_platform_get_num_bits_addr() -> Addr { - store([0xadu8, 0x44u8, 0xc9u8, 0x04u8, 0x49u8, 0xfau8, 0xf8u8, 0x6fu8, - 0x63u8, 0xc1u8, 0x70u8, 0xf0u8, 0x92u8, 0xe2u8, 0x24u8, 0x9bu8, - 0xccu8, 0xabu8, 0x1eu8, 0x74u8, 0x1cu8, 0x1fu8, 0xe1u8, 0x0du8, - 0xf8u8, 0x4cu8, 0x95u8, 0xb4u8, 0x4bu8, 0x38u8, 0x43u8, 0x71u8]) + store([0xf5u8, 0xd2u8, 0x56u8, 0xc1u8, 0xddu8, 0x79u8, 0x4du8, 0x02u8, + 0xcfu8, 0xdfu8, 0x17u8, 0x62u8, 0xc9u8, 0xe4u8, 0x1bu8, 0x13u8, + 0xabu8, 0xe5u8, 0xbdu8, 0xddu8, 0xe1u8, 0x2du8, 0x92u8, 0x9du8, + 0x02u8, 0xadu8, 0xa3u8, 0x7eu8, 0x4fu8, 0x40u8, 0xe8u8, 0x5fu8]) } fn subtype_val_addr() -> Addr { - store([0xadu8, 0x58u8, 0xc3u8, 0x65u8, 0x60u8, 0x44u8, 0xd7u8, 0xfau8, - 0xefu8, 0x69u8, 0x76u8, 0x37u8, 0xf5u8, 0x16u8, 0xd7u8, 0x26u8, - 0x74u8, 0xd3u8, 0x5bu8, 0x18u8, 0x66u8, 0x3cu8, 0xb2u8, 0x63u8, - 0xf7u8, 0xccu8, 0xcau8, 0x8cu8, 0xddu8, 0x2eu8, 0x6fu8, 0x00u8]) + store([0x0bu8, 0x59u8, 0x58u8, 0xa3u8, 0xc8u8, 0x22u8, 0xc9u8, 0x9eu8, + 0x86u8, 0x43u8, 0xa2u8, 0x7fu8, 0x0bu8, 0x92u8, 0x8du8, 0xfbu8, + 0x82u8, 0xc4u8, 0x54u8, 0x47u8, 0xbeu8, 0xe0u8, 0x35u8, 0x3cu8, + 0x20u8, 0x0au8, 0xd1u8, 0xb7u8, 0xd0u8, 0xe4u8, 0x60u8, 0x92u8]) } fn punit_size_of_1_addr() -> Addr { - store([0x48u8, 0x91u8, 0x87u8, 0xe9u8, 0xcdu8, 0x03u8, 0xabu8, 0xebu8, - 0xc1u8, 0x2au8, 0x13u8, 0x35u8, 0xc6u8, 0x28u8, 0xd6u8, 0x42u8, - 0xeau8, 0x2au8, 0x48u8, 0xbdu8, 0xc2u8, 0x62u8, 0xc8u8, 0x5fu8, - 0x84u8, 0x8fu8, 0x10u8, 0x11u8, 0xe7u8, 0x3fu8, 0x61u8, 0x0au8]) + store([0x7bu8, 0xd8u8, 0xe1u8, 0x9fu8, 0x47u8, 0xf6u8, 0xeau8, 0xe6u8, + 0x20u8, 0xa5u8, 0xc3u8, 0x9fu8, 0x24u8, 0x3cu8, 0xe4u8, 0x15u8, + 0xddu8, 0x6au8, 0x77u8, 0xf0u8, 0x95u8, 0x90u8, 0xf4u8, 0xc2u8, + 0x27u8, 0xceu8, 0xf3u8, 0x63u8, 0x00u8, 0x7fu8, 0x40u8, 0x12u8]) } fn size_of_size_of_addr() -> Addr { - store([0x71u8, 0x05u8, 0xeau8, 0xf4u8, 0xc5u8, 0x2cu8, 0xe3u8, 0xa1u8, - 0x93u8, 0x72u8, 0xa8u8, 0x7fu8, 0xacu8, 0x57u8, 0xa8u8, 0xf9u8, - 0x59u8, 0x8au8, 0x24u8, 0x63u8, 0x34u8, 0xceu8, 0x6eu8, 0xffu8, - 0xaeu8, 0xe3u8, 0xe4u8, 0x8eu8, 0x7eu8, 0x6du8, 0x3au8, 0xadu8]) + store([0x38u8, 0x97u8, 0x15u8, 0xf9u8, 0x1eu8, 0x66u8, 0x68u8, 0x3du8, + 0xc7u8, 0x10u8, 0x8cu8, 0xcdu8, 0x85u8, 0x3eu8, 0xfcu8, 0xe9u8, + 0x29u8, 0x49u8, 0x51u8, 0x2fu8, 0xa6u8, 0x59u8, 0xadu8, 0x3cu8, + 0x19u8, 0x02u8, 0xe7u8, 0x54u8, 0x69u8, 0x29u8, 0x19u8, 0xcdu8]) } fn punit_addr() -> Addr { - store([0x16u8, 0xa2u8, 0xdcu8, 0x76u8, 0xa2u8, 0xcfu8, 0xccu8, 0x94u8, - 0x40u8, 0xf4u8, 0x43u8, 0xc6u8, 0x66u8, 0x53u8, 0x6fu8, 0x2fu8, - 0xa9u8, 0x9cu8, 0x02u8, 0x50u8, 0xb6u8, 0x42u8, 0xfdu8, 0x39u8, - 0x71u8, 0xfbu8, 0xadu8, 0x25u8, 0xd5u8, 0x31u8, 0x26u8, 0x2au8]) + store([0x2du8, 0xfcu8, 0x16u8, 0xafu8, 0x01u8, 0xb8u8, 0x2bu8, 0x3bu8, + 0x91u8, 0xc2u8, 0xffu8, 0x70u8, 0x44u8, 0x09u8, 0xd7u8, 0x62u8, + 0x36u8, 0xa8u8, 0x3fu8, 0x95u8, 0x6cu8, 0x0cu8, 0x6eu8, 0x66u8, + 0x59u8, 0xa6u8, 0x4fu8, 0xe2u8, 0x1du8, 0x76u8, 0x69u8, 0x5bu8]) } fn unit_addr() -> Addr { - store([0x21u8, 0x1bu8, 0xf5u8, 0xedu8, 0x2fu8, 0x4cu8, 0x51u8, 0xd4u8, - 0x57u8, 0x50u8, 0xe7u8, 0x5bu8, 0x89u8, 0x1fu8, 0xa2u8, 0x67u8, - 0xdbu8, 0x4du8, 0x4eu8, 0x6fu8, 0x46u8, 0xc2u8, 0x07u8, 0x92u8, - 0x82u8, 0xfau8, 0x2bu8, 0xe3u8, 0xe8u8, 0x87u8, 0x81u8, 0xa1u8]) + store([0x92u8, 0x32u8, 0x49u8, 0x86u8, 0x67u8, 0xf7u8, 0x65u8, 0xf4u8, + 0x37u8, 0xdeu8, 0xdau8, 0xacu8, 0x82u8, 0x8eu8, 0x55u8, 0x5fu8, + 0x6cu8, 0xc6u8, 0x7au8, 0x20u8, 0xe6u8, 0xdbu8, 0x28u8, 0xf6u8, + 0x14u8, 0xfdu8, 0xf3u8, 0xc2u8, 0x62u8, 0x71u8, 0x0fu8, 0xebu8]) } fn nat_addr() -> Addr { - store([0xfcu8, 0x0eu8, 0x1eu8, 0x91u8, 0x2fu8, 0x2du8, 0x7fu8, 0x12u8, - 0x04u8, 0x9au8, 0x5bu8, 0x31u8, 0x5du8, 0x76u8, 0xeeu8, 0xc2u8, - 0x95u8, 0x62u8, 0xe3u8, 0x4du8, 0xc3u8, 0x9eu8, 0xbcu8, 0xa2u8, - 0x52u8, 0x87u8, 0xaeu8, 0x58u8, 0x80u8, 0x7du8, 0xb1u8, 0x37u8]) + store([0x39u8, 0x8au8, 0x77u8, 0x06u8, 0xcfu8, 0x13u8, 0xf2u8, 0x23u8, + 0x99u8, 0x2du8, 0x17u8, 0x3du8, 0xceu8, 0x07u8, 0x94u8, 0x68u8, + 0x57u8, 0x24u8, 0x0fu8, 0x49u8, 0xafu8, 0xccu8, 0x74u8, 0x37u8, + 0x23u8, 0xe8u8, 0x39u8, 0xf8u8, 0xf3u8, 0xf2u8, 0xb6u8, 0x31u8]) } fn nat_zero_addr() -> Addr { - store([0xfau8, 0xc8u8, 0x2fu8, 0x0du8, 0x25u8, 0x55u8, 0xd6u8, 0xa6u8, - 0x3eu8, 0x1bu8, 0x8au8, 0x1fu8, 0xe8u8, 0xd8u8, 0x6bu8, 0xd2u8, - 0x93u8, 0x19u8, 0x7fu8, 0x39u8, 0xc3u8, 0x96u8, 0xfdu8, 0xc2u8, - 0x3cu8, 0x12u8, 0x75u8, 0xc6u8, 0x0fu8, 0x18u8, 0x2bu8, 0x37u8]) + store([0xd3u8, 0x97u8, 0x37u8, 0x01u8, 0x57u8, 0xfbu8, 0x9au8, 0xe2u8, + 0xc6u8, 0xe1u8, 0xedu8, 0xa7u8, 0x9fu8, 0xebu8, 0x10u8, 0xbfu8, + 0x49u8, 0x74u8, 0x01u8, 0x74u8, 0x1au8, 0xbau8, 0x78u8, 0x8fu8, + 0xabu8, 0x72u8, 0x6cu8, 0xfau8, 0x4cu8, 0x46u8, 0x7du8, 0xb6u8]) } fn nat_succ_addr() -> Addr { - store([0x71u8, 0x90u8, 0xceu8, 0x56u8, 0xf6u8, 0xa2u8, 0xa8u8, 0x47u8, - 0xb9u8, 0x44u8, 0xa3u8, 0x55u8, 0xe3u8, 0xecu8, 0x59u8, 0x5au8, - 0x40u8, 0x36u8, 0xfbu8, 0x07u8, 0xe3u8, 0xc3u8, 0xdbu8, 0x9du8, - 0x90u8, 0x64u8, 0xfcu8, 0x04u8, 0x1bu8, 0xe7u8, 0x2bu8, 0x64u8]) + store([0xdeu8, 0xf5u8, 0x2du8, 0x1du8, 0xadu8, 0x5fu8, 0x10u8, 0xcfu8, + 0x98u8, 0x93u8, 0xc9u8, 0x45u8, 0xe1u8, 0x69u8, 0x71u8, 0x8du8, + 0x62u8, 0xb1u8, 0x5eu8, 0x2du8, 0xd2u8, 0xc9u8, 0x06u8, 0x6eu8, + 0x59u8, 0x7bu8, 0x9du8, 0x45u8, 0x70u8, 0xbau8, 0x05u8, 0x6eu8]) } fn nat_pred_addr() -> Addr { - store([0x4eu8, 0xd5u8, 0xffu8, 0xfbu8, 0x03u8, 0xaeu8, 0x5eu8, 0x6bu8, - 0x7au8, 0x0du8, 0x9fu8, 0x33u8, 0x79u8, 0xaau8, 0x76u8, 0x9eu8, - 0x5cu8, 0xa8u8, 0x18u8, 0x8cu8, 0xacu8, 0xbdu8, 0xf1u8, 0xe2u8, - 0x0du8, 0xcau8, 0x4bu8, 0xadu8, 0x27u8, 0xf2u8, 0x53u8, 0x33u8]) + store([0x91u8, 0x4fu8, 0x9cu8, 0x01u8, 0x88u8, 0x48u8, 0x53u8, 0x65u8, + 0x2eu8, 0x92u8, 0x24u8, 0xdcu8, 0x51u8, 0x1fu8, 0x86u8, 0x7du8, + 0x54u8, 0x08u8, 0x51u8, 0x7fu8, 0x3bu8, 0xebu8, 0x31u8, 0x92u8, + 0xfcu8, 0x44u8, 0x77u8, 0xe0u8, 0xe9u8, 0x59u8, 0x4cu8, 0x88u8]) } fn nat_add_addr() -> Addr { - store([0x9du8, 0x83u8, 0x30u8, 0x7du8, 0x55u8, 0x2eu8, 0x68u8, 0x1fu8, - 0x4cu8, 0xceu8, 0xffu8, 0x7fu8, 0x78u8, 0x3bu8, 0x5au8, 0x64u8, - 0xe0u8, 0x02u8, 0x57u8, 0x5eu8, 0xdcu8, 0xb1u8, 0xc0u8, 0x4fu8, - 0xa0u8, 0xc5u8, 0x66u8, 0x2cu8, 0xe2u8, 0xddu8, 0x34u8, 0x38u8]) + store([0xd6u8, 0xf6u8, 0x2au8, 0x97u8, 0x79u8, 0x10u8, 0x8fu8, 0x9fu8, + 0xb6u8, 0xb6u8, 0x6bu8, 0x31u8, 0xccu8, 0x94u8, 0xc3u8, 0xd8u8, + 0x4cu8, 0xa7u8, 0x2du8, 0x8bu8, 0xeau8, 0x18u8, 0x5eu8, 0x13u8, + 0x13u8, 0x7cu8, 0x50u8, 0xc7u8, 0xefu8, 0x84u8, 0xc9u8, 0x69u8]) } fn nat_sub_addr() -> Addr { - store([0x9eu8, 0x86u8, 0xffu8, 0x43u8, 0xb1u8, 0x5au8, 0xebu8, 0xafu8, - 0xb3u8, 0xdfu8, 0x61u8, 0x0au8, 0x96u8, 0xddu8, 0x44u8, 0x92u8, - 0xffu8, 0x9cu8, 0xd8u8, 0xaau8, 0xb8u8, 0x7au8, 0x82u8, 0x02u8, - 0x5bu8, 0x61u8, 0x7cu8, 0x9au8, 0x0bu8, 0xbfu8, 0x62u8, 0x80u8]) + store([0xfdu8, 0xbdu8, 0x5fu8, 0xefu8, 0x40u8, 0x14u8, 0x9cu8, 0x85u8, + 0x33u8, 0x3cu8, 0x6fu8, 0x3cu8, 0xceu8, 0xbbu8, 0x4bu8, 0xe7u8, + 0x41u8, 0x27u8, 0x0du8, 0x20u8, 0x66u8, 0x33u8, 0x6cu8, 0xb2u8, + 0xeeu8, 0xf8u8, 0x76u8, 0x23u8, 0x74u8, 0x4bu8, 0x72u8, 0xb0u8]) } fn nat_mul_addr() -> Addr { - store([0x9bu8, 0xc1u8, 0x35u8, 0x39u8, 0xb6u8, 0x8bu8, 0x0eu8, 0x1cu8, - 0x5au8, 0x53u8, 0x81u8, 0x85u8, 0x80u8, 0xaau8, 0x09u8, 0x6au8, - 0x65u8, 0x90u8, 0x7fu8, 0x63u8, 0xafu8, 0x45u8, 0x88u8, 0xa1u8, - 0xe9u8, 0x1eu8, 0x14u8, 0xd3u8, 0x4du8, 0x9eu8, 0x4du8, 0x86u8]) + store([0x66u8, 0x49u8, 0x66u8, 0x56u8, 0x07u8, 0xb0u8, 0x75u8, 0x0cu8, + 0x2cu8, 0xa7u8, 0x3fu8, 0x45u8, 0xdeu8, 0x60u8, 0x0fu8, 0x21u8, + 0xcbu8, 0x67u8, 0x03u8, 0x98u8, 0x50u8, 0x48u8, 0x65u8, 0xbbu8, + 0x97u8, 0x97u8, 0x24u8, 0x38u8, 0x01u8, 0x4fu8, 0x96u8, 0xd9u8]) } fn nat_pow_addr() -> Addr { - store([0xb5u8, 0x2cu8, 0x4du8, 0x0du8, 0x38u8, 0x78u8, 0xf2u8, 0x87u8, - 0x71u8, 0x9fu8, 0x65u8, 0xd0u8, 0x08u8, 0x8au8, 0x26u8, 0x9au8, - 0xf0u8, 0xf6u8, 0xe5u8, 0xb1u8, 0xb7u8, 0xefu8, 0x56u8, 0x29u8, - 0x83u8, 0x09u8, 0x63u8, 0xdcu8, 0xb7u8, 0x5eu8, 0x6cu8, 0xeeu8]) + store([0x33u8, 0xc6u8, 0x04u8, 0x45u8, 0x1du8, 0x01u8, 0xcbu8, 0x19u8, + 0xa4u8, 0x33u8, 0x66u8, 0x82u8, 0x46u8, 0xb9u8, 0x8fu8, 0x6eu8, + 0x87u8, 0x4bu8, 0xd6u8, 0x30u8, 0xb7u8, 0x8au8, 0x79u8, 0x1du8, + 0x7au8, 0x37u8, 0x3au8, 0x97u8, 0x98u8, 0x49u8, 0xa1u8, 0xcfu8]) } fn nat_gcd_addr() -> Addr { - store([0x74u8, 0x36u8, 0xd9u8, 0xfau8, 0x7cu8, 0xceu8, 0x3eu8, 0xf9u8, - 0x1bu8, 0xc9u8, 0x90u8, 0x3cu8, 0xc5u8, 0xaau8, 0x32u8, 0xd4u8, - 0x13u8, 0xdau8, 0x2fu8, 0x6cu8, 0xa7u8, 0xc2u8, 0x1au8, 0x92u8, - 0x35u8, 0xb4u8, 0x1au8, 0x2fu8, 0xc4u8, 0x82u8, 0xdfu8, 0xfcu8]) + store([0x3bu8, 0xe4u8, 0x83u8, 0x57u8, 0xaeu8, 0x17u8, 0xf7u8, 0x4du8, + 0x4du8, 0xf2u8, 0x7du8, 0x69u8, 0x7au8, 0xedu8, 0x3fu8, 0x47u8, + 0xc1u8, 0x30u8, 0x79u8, 0x41u8, 0xf4u8, 0x1au8, 0xffu8, 0xcfu8, + 0x74u8, 0xdau8, 0x5fu8, 0x66u8, 0xd5u8, 0x11u8, 0xa7u8, 0x97u8]) } fn nat_mod_addr() -> Addr { - store([0x6eu8, 0xa1u8, 0xa4u8, 0x4fu8, 0x73u8, 0x78u8, 0xe3u8, 0x72u8, - 0xfeu8, 0xb5u8, 0x8fu8, 0xb5u8, 0x2cu8, 0x80u8, 0x84u8, 0x62u8, - 0x60u8, 0x57u8, 0xb3u8, 0xf3u8, 0x87u8, 0x49u8, 0x5eu8, 0x76u8, - 0x00u8, 0xb9u8, 0x71u8, 0xa3u8, 0x8bu8, 0x24u8, 0x42u8, 0x76u8]) + store([0x51u8, 0x79u8, 0x63u8, 0x8bu8, 0x82u8, 0xccu8, 0x83u8, 0x37u8, + 0x91u8, 0x4au8, 0x7bu8, 0xcau8, 0xadu8, 0x85u8, 0x8cu8, 0x85u8, + 0x88u8, 0x88u8, 0x44u8, 0xe9u8, 0xa2u8, 0x92u8, 0x43u8, 0x0cu8, + 0xacu8, 0x51u8, 0xe5u8, 0xeau8, 0xdcu8, 0x41u8, 0xa1u8, 0xafu8]) } fn nat_div_addr() -> Addr { - store([0xd0u8, 0x91u8, 0x95u8, 0x70u8, 0xf8u8, 0x93u8, 0x2du8, 0xdfu8, - 0x5du8, 0xffu8, 0x43u8, 0x00u8, 0xabu8, 0x76u8, 0x67u8, 0xd1u8, - 0xbau8, 0xabu8, 0x93u8, 0x24u8, 0xdbu8, 0xc1u8, 0x36u8, 0xacu8, - 0x9cu8, 0x81u8, 0x29u8, 0x2eu8, 0xd1u8, 0xc8u8, 0x1fu8, 0xe9u8]) + store([0x89u8, 0xdeu8, 0xcau8, 0x86u8, 0xddu8, 0x8fu8, 0x00u8, 0x66u8, + 0xa5u8, 0x06u8, 0x4fu8, 0xdbu8, 0x19u8, 0xa2u8, 0xc6u8, 0x89u8, + 0x7au8, 0x3au8, 0x98u8, 0x67u8, 0xcau8, 0xadu8, 0xc0u8, 0x4fu8, + 0x77u8, 0x8du8, 0x5cu8, 0x5cu8, 0xd0u8, 0x22u8, 0x53u8, 0x62u8]) } fn nat_land_addr() -> Addr { - store([0x44u8, 0x51u8, 0x43u8, 0x20u8, 0xbdu8, 0x93u8, 0x35u8, 0xa0u8, - 0x89u8, 0x42u8, 0xe7u8, 0x7du8, 0xe8u8, 0x07u8, 0x7eu8, 0x38u8, - 0x3fu8, 0x11u8, 0xa0u8, 0xf6u8, 0x15u8, 0x0cu8, 0x00u8, 0x0cu8, - 0x98u8, 0x23u8, 0xc8u8, 0x74u8, 0x67u8, 0x58u8, 0x99u8, 0x65u8]) + store([0x81u8, 0x8au8, 0xbbu8, 0x33u8, 0x11u8, 0x50u8, 0x40u8, 0x0du8, + 0x10u8, 0xb3u8, 0x4fu8, 0xaeu8, 0x4du8, 0xfbu8, 0x94u8, 0x26u8, + 0x74u8, 0x1cu8, 0x46u8, 0x07u8, 0xbau8, 0xeeu8, 0xd8u8, 0xd9u8, + 0x62u8, 0x71u8, 0xbau8, 0x16u8, 0x59u8, 0x05u8, 0x8eu8, 0xf8u8]) } fn nat_lor_addr() -> Addr { - store([0x18u8, 0x4cu8, 0xa6u8, 0xa9u8, 0x32u8, 0xa4u8, 0xc5u8, 0xfdu8, - 0x0au8, 0x2cu8, 0x16u8, 0x95u8, 0x01u8, 0xd2u8, 0xd5u8, 0x04u8, - 0x8bu8, 0xb7u8, 0x43u8, 0xbdu8, 0x16u8, 0x6fu8, 0x96u8, 0xffu8, - 0xecu8, 0x9du8, 0x41u8, 0x01u8, 0xe5u8, 0x4eu8, 0x98u8, 0x2bu8]) + store([0x9bu8, 0x76u8, 0xf3u8, 0x2bu8, 0xbbu8, 0x1du8, 0xbdu8, 0xf4u8, + 0xffu8, 0x68u8, 0xe0u8, 0x22u8, 0x12u8, 0x25u8, 0x01u8, 0x5du8, + 0xf0u8, 0xcau8, 0x2du8, 0x2au8, 0x60u8, 0x23u8, 0xc1u8, 0xa8u8, + 0x13u8, 0x06u8, 0xd4u8, 0x02u8, 0x0du8, 0x4eu8, 0xf3u8, 0x97u8]) } fn nat_xor_addr() -> Addr { - store([0x16u8, 0x3au8, 0x8cu8, 0x28u8, 0x00u8, 0xcau8, 0x51u8, 0xdau8, - 0xafu8, 0xfeu8, 0x1bu8, 0x71u8, 0x57u8, 0x51u8, 0x27u8, 0x94u8, - 0x2au8, 0x05u8, 0x30u8, 0x04u8, 0x40u8, 0x52u8, 0x4bu8, 0x14u8, - 0x5cu8, 0x8fu8, 0xcdu8, 0xccu8, 0x5eu8, 0xe0u8, 0x08u8, 0xb6u8]) + store([0x97u8, 0xe3u8, 0x25u8, 0xa9u8, 0x6au8, 0x6au8, 0x18u8, 0x27u8, + 0x19u8, 0x4eu8, 0xebu8, 0x7du8, 0x2au8, 0xa0u8, 0xd9u8, 0x19u8, + 0x21u8, 0x07u8, 0x3au8, 0xefu8, 0x9cu8, 0x2du8, 0x33u8, 0x3cu8, + 0x24u8, 0x61u8, 0x3eu8, 0x9au8, 0xc9u8, 0x56u8, 0xedu8, 0x29u8]) } fn nat_shift_left_addr() -> Addr { - store([0x16u8, 0xbdu8, 0x10u8, 0x36u8, 0x5eu8, 0xe6u8, 0xfau8, 0x40u8, - 0xb4u8, 0xa1u8, 0xddu8, 0xc0u8, 0xddu8, 0x26u8, 0xc8u8, 0xa4u8, - 0x9du8, 0xb8u8, 0xf8u8, 0xb1u8, 0xebu8, 0x56u8, 0xb2u8, 0xacu8, - 0x2au8, 0x17u8, 0x9eu8, 0xa2u8, 0x44u8, 0x05u8, 0x98u8, 0xd7u8]) + store([0xdcu8, 0x81u8, 0xe4u8, 0x1cu8, 0xadu8, 0x11u8, 0x90u8, 0x37u8, + 0x7du8, 0xbeu8, 0x60u8, 0x4bu8, 0xfcu8, 0x3au8, 0xfeu8, 0x65u8, + 0x8au8, 0x41u8, 0x3bu8, 0x9au8, 0x2du8, 0xcfu8, 0xbcu8, 0xabu8, + 0x79u8, 0xfau8, 0xd7u8, 0xb7u8, 0xa5u8, 0xcdu8, 0xd9u8, 0x54u8]) } fn nat_shift_right_addr() -> Addr { - store([0x6fu8, 0xe2u8, 0x1eu8, 0x35u8, 0xa9u8, 0xa3u8, 0x08u8, 0xdeu8, - 0xafu8, 0xe5u8, 0x32u8, 0x10u8, 0xdbu8, 0x5bu8, 0x28u8, 0x56u8, - 0xc1u8, 0x85u8, 0xdcu8, 0x14u8, 0x7eu8, 0xf2u8, 0x71u8, 0x7cu8, - 0x0eu8, 0x73u8, 0xa0u8, 0xfau8, 0x3au8, 0xd3u8, 0x16u8, 0x90u8]) + store([0x6du8, 0xb4u8, 0x93u8, 0x04u8, 0xbfu8, 0x0fu8, 0x5au8, 0xcbu8, + 0xfdu8, 0x1du8, 0x9du8, 0x9au8, 0x0cu8, 0x1bu8, 0x7au8, 0xe2u8, + 0x0eu8, 0xf9u8, 0x9du8, 0x07u8, 0x37u8, 0x88u8, 0x70u8, 0x56u8, + 0x12u8, 0x9fu8, 0x5bu8, 0x5cu8, 0xb5u8, 0xa9u8, 0xbau8, 0x8au8]) } fn nat_beq_addr() -> Addr { - store([0x49u8, 0xa1u8, 0x67u8, 0x14u8, 0xbdu8, 0x7bu8, 0x82u8, 0x03u8, - 0x7cu8, 0xd8u8, 0xe7u8, 0x76u8, 0x33u8, 0x1du8, 0x82u8, 0x62u8, - 0x82u8, 0x9bu8, 0xc7u8, 0x0cu8, 0x8eu8, 0xe3u8, 0x63u8, 0xc8u8, - 0x66u8, 0xc7u8, 0x06u8, 0x0bu8, 0xf3u8, 0x66u8, 0xcdu8, 0x9bu8]) + store([0xa3u8, 0x4au8, 0xb2u8, 0xdau8, 0xbau8, 0x34u8, 0x83u8, 0x9eu8, + 0x85u8, 0x1fu8, 0xa3u8, 0x67u8, 0x51u8, 0x24u8, 0x56u8, 0x6fu8, + 0x9fu8, 0x4du8, 0xcdu8, 0xe5u8, 0x97u8, 0x34u8, 0x9eu8, 0xcdu8, + 0x54u8, 0xaeu8, 0x32u8, 0xf8u8, 0x42u8, 0x4eu8, 0x44u8, 0xb8u8]) } fn nat_ble_addr() -> Addr { - store([0xf5u8, 0xbbu8, 0x24u8, 0x57u8, 0x67u8, 0xfdu8, 0xbcu8, 0x68u8, - 0x3bu8, 0xeeu8, 0x9eu8, 0x1cu8, 0xa8u8, 0xd9u8, 0xa7u8, 0x24u8, - 0x74u8, 0x26u8, 0xfbu8, 0x24u8, 0xc6u8, 0x7bu8, 0x2cu8, 0x3fu8, - 0x22u8, 0x7du8, 0xe5u8, 0x1bu8, 0x5fu8, 0x83u8, 0x9bu8, 0x26u8]) + store([0xdeu8, 0x0bu8, 0xefu8, 0xa8u8, 0x4fu8, 0xaau8, 0x22u8, 0xd1u8, + 0x39u8, 0x43u8, 0x79u8, 0xa0u8, 0xbau8, 0x67u8, 0x29u8, 0x6eu8, + 0x11u8, 0x66u8, 0x60u8, 0xf7u8, 0x81u8, 0xb4u8, 0xebu8, 0x63u8, + 0x9du8, 0xbbu8, 0xabu8, 0xa2u8, 0x00u8, 0xefu8, 0x2bu8, 0xf8u8]) } fn str_addr() -> Addr { - store([0x42u8, 0x26u8, 0x58u8, 0xd0u8, 0x43u8, 0xeeu8, 0x48u8, 0x2fu8, - 0x71u8, 0x02u8, 0xd2u8, 0xf6u8, 0xeau8, 0x65u8, 0x96u8, 0x66u8, - 0x48u8, 0x08u8, 0xe8u8, 0x99u8, 0xabu8, 0xadu8, 0x62u8, 0x80u8, - 0x80u8, 0x47u8, 0x8au8, 0x1eu8, 0x91u8, 0x89u8, 0xf0u8, 0xaau8]) + store([0x7au8, 0xb2u8, 0xd5u8, 0x2au8, 0xc5u8, 0x2fu8, 0xd1u8, 0xf5u8, + 0x18u8, 0x09u8, 0xb7u8, 0x18u8, 0xe5u8, 0x3cu8, 0xd0u8, 0x58u8, + 0xacu8, 0x4bu8, 0x50u8, 0xd6u8, 0x51u8, 0x50u8, 0xe7u8, 0x8au8, + 0xe6u8, 0x19u8, 0x13u8, 0x9cu8, 0xcfu8, 0x13u8, 0xc8u8, 0xfdu8]) } fn string_utf8_byte_size_addr() -> Addr { - store([0xccu8, 0x6cu8, 0xdcu8, 0x73u8, 0xe0u8, 0xdfu8, 0x40u8, 0x4bu8, - 0xa7u8, 0x68u8, 0x5cu8, 0x73u8, 0x3eu8, 0xbbu8, 0xe7u8, 0xc1u8, - 0xaeu8, 0xccu8, 0x6eu8, 0xf4u8, 0x65u8, 0x03u8, 0xd1u8, 0x0au8, - 0xadu8, 0x58u8, 0xbfu8, 0x70u8, 0xf8u8, 0x4au8, 0x48u8, 0x58u8]) + store([0xdeu8, 0xf4u8, 0x43u8, 0x3du8, 0x95u8, 0x47u8, 0xb5u8, 0x31u8, + 0x75u8, 0xe2u8, 0x4au8, 0x3au8, 0xc1u8, 0x82u8, 0xc8u8, 0x8bu8, + 0x07u8, 0x2au8, 0xf0u8, 0xd4u8, 0xadu8, 0x33u8, 0xfdu8, 0x04u8, + 0xecu8, 0x4cu8, 0xf2u8, 0xbau8, 0x3du8, 0x95u8, 0xeau8, 0x93u8]) } fn string_back_addr() -> Addr { - store([0xf6u8, 0x06u8, 0x6fu8, 0xc6u8, 0x24u8, 0x91u8, 0xfdu8, 0x4cu8, - 0x48u8, 0xd4u8, 0xdau8, 0xf3u8, 0xb9u8, 0xbeu8, 0xbau8, 0x72u8, - 0xe2u8, 0xa0u8, 0xb8u8, 0x04u8, 0x0fu8, 0xcbu8, 0xd9u8, 0x9fu8, - 0xb7u8, 0x29u8, 0xabu8, 0xf5u8, 0x6au8, 0x9cu8, 0x07u8, 0xc4u8]) + store([0xe9u8, 0x5cu8, 0x8du8, 0x87u8, 0x6eu8, 0x7cu8, 0xcfu8, 0x78u8, + 0x04u8, 0x18u8, 0x61u8, 0x5eu8, 0x33u8, 0xb7u8, 0x47u8, 0xa2u8, + 0x45u8, 0xd9u8, 0x4fu8, 0xacu8, 0xd7u8, 0x56u8, 0x7fu8, 0xecu8, + 0xbeu8, 0x7au8, 0xe7u8, 0x3au8, 0x5au8, 0xc0u8, 0x92u8, 0x06u8]) } fn string_legacy_back_addr() -> Addr { - store([0xd5u8, 0xe5u8, 0x43u8, 0xa5u8, 0xb6u8, 0xbdu8, 0xe8u8, 0x8du8, - 0xc3u8, 0x85u8, 0x4du8, 0x4cu8, 0x2bu8, 0x9au8, 0x12u8, 0xacu8, - 0x27u8, 0x09u8, 0x76u8, 0xbfu8, 0x41u8, 0x02u8, 0xa6u8, 0xb3u8, - 0x3fu8, 0x55u8, 0xa9u8, 0x0du8, 0xb3u8, 0x24u8, 0x26u8, 0x8fu8]) + store([0x6bu8, 0xb6u8, 0x16u8, 0x2au8, 0xacu8, 0x7du8, 0x6au8, 0x01u8, + 0xb6u8, 0xecu8, 0x05u8, 0x58u8, 0x06u8, 0x64u8, 0xe8u8, 0xa7u8, + 0xf0u8, 0xd4u8, 0xb0u8, 0xecu8, 0x1fu8, 0xc5u8, 0xafu8, 0xaau8, + 0xe6u8, 0x60u8, 0x18u8, 0xe9u8, 0xa1u8, 0x93u8, 0x6du8, 0xacu8]) } fn string_to_byte_array_addr() -> Addr { - store([0xa0u8, 0x77u8, 0x36u8, 0xecu8, 0x99u8, 0x9fu8, 0xdcu8, 0xb8u8, - 0x75u8, 0x30u8, 0x67u8, 0x49u8, 0x7fu8, 0x9fu8, 0x97u8, 0xb4u8, - 0x61u8, 0xf2u8, 0xa1u8, 0x4eu8, 0x81u8, 0x69u8, 0xcdu8, 0x11u8, - 0x28u8, 0x7du8, 0xc7u8, 0x3cu8, 0xdfu8, 0xd7u8, 0x42u8, 0xaau8]) + store([0xedu8, 0x43u8, 0xc7u8, 0x7eu8, 0x55u8, 0x55u8, 0x93u8, 0xb6u8, + 0xcdu8, 0x0du8, 0x4bu8, 0xfbu8, 0xc4u8, 0x27u8, 0x3bu8, 0xa1u8, + 0x22u8, 0xe1u8, 0xc0u8, 0xcdu8, 0xf1u8, 0x09u8, 0x05u8, 0x71u8, + 0x61u8, 0x2au8, 0x95u8, 0x2fu8, 0x94u8, 0x1eu8, 0xadu8, 0xb1u8]) } fn byte_array_empty_addr() -> Addr { - store([0xc0u8, 0x7fu8, 0x15u8, 0x89u8, 0xbdu8, 0x7du8, 0xccu8, 0x55u8, - 0x6eu8, 0x38u8, 0x4eu8, 0x42u8, 0xbau8, 0xb1u8, 0x42u8, 0xa8u8, - 0x4fu8, 0x7au8, 0x62u8, 0x55u8, 0xd3u8, 0x9bu8, 0x59u8, 0xb0u8, - 0xf9u8, 0x00u8, 0x19u8, 0x80u8, 0x47u8, 0x25u8, 0x22u8, 0x96u8]) + store([0x7cu8, 0xfbu8, 0xa8u8, 0xfau8, 0x95u8, 0x84u8, 0x7cu8, 0x21u8, + 0x3au8, 0xa4u8, 0x06u8, 0x61u8, 0x10u8, 0xbau8, 0x01u8, 0xa9u8, + 0x7fu8, 0xb5u8, 0x97u8, 0xdau8, 0xf2u8, 0x9fu8, 0x5cu8, 0x07u8, + 0xf7u8, 0x23u8, 0x66u8, 0x07u8, 0x2fu8, 0x25u8, 0x07u8, 0x44u8]) } fn char_of_nat_addr() -> Addr { - store([0x28u8, 0xdcu8, 0x1bu8, 0x3du8, 0x3du8, 0x2eu8, 0x01u8, 0x15u8, - 0x29u8, 0xc7u8, 0x1cu8, 0x9du8, 0x44u8, 0x18u8, 0x24u8, 0x8fu8, - 0x60u8, 0x60u8, 0xdbu8, 0xfbu8, 0x1cu8, 0x7eu8, 0x97u8, 0xdbu8, - 0x1cu8, 0x57u8, 0x2au8, 0x56u8, 0x57u8, 0x87u8, 0xefu8, 0x61u8]) + store([0x1au8, 0x4cu8, 0x66u8, 0xf7u8, 0x67u8, 0x60u8, 0xf5u8, 0xefu8, + 0x38u8, 0x6du8, 0xe0u8, 0x89u8, 0x68u8, 0x2au8, 0x55u8, 0xb7u8, + 0x52u8, 0x13u8, 0x1eu8, 0x14u8, 0xa0u8, 0x85u8, 0x57u8, 0xc4u8, + 0x46u8, 0x5eu8, 0xd1u8, 0x7fu8, 0xe0u8, 0xc4u8, 0xdcu8, 0x86u8]) } fn char_type_addr() -> Addr { - store([0x2fu8, 0x96u8, 0xb8u8, 0xdau8, 0x29u8, 0xa3u8, 0x8bu8, 0x17u8, - 0x7fu8, 0xc3u8, 0x25u8, 0x53u8, 0xd5u8, 0x38u8, 0xd5u8, 0xd4u8, - 0x50u8, 0x21u8, 0x2fu8, 0xd3u8, 0xe6u8, 0xfeu8, 0xd9u8, 0x5du8, - 0x61u8, 0xc8u8, 0x17u8, 0x83u8, 0x7du8, 0x29u8, 0xa3u8, 0x4fu8]) + store([0x29u8, 0xddu8, 0x2du8, 0x19u8, 0x86u8, 0xa5u8, 0x25u8, 0xbdu8, + 0xdeu8, 0x49u8, 0xb4u8, 0xadu8, 0x2du8, 0xefu8, 0xc3u8, 0x49u8, + 0xceu8, 0xc7u8, 0x1du8, 0x04u8, 0x84u8, 0xcdu8, 0x13u8, 0xf2u8, + 0xdau8, 0x92u8, 0xf1u8, 0xfcu8, 0xe8u8, 0x9au8, 0x4cu8, 0x79u8]) } fn string_of_list_addr() -> Addr { - store([0x40u8, 0x5du8, 0x36u8, 0xf5u8, 0xf6u8, 0x47u8, 0x9cu8, 0x40u8, - 0x21u8, 0x6fu8, 0xf7u8, 0xbbu8, 0xbau8, 0x10u8, 0xb0u8, 0x77u8, - 0x84u8, 0x8eu8, 0xc3u8, 0x3au8, 0xf0u8, 0x3eu8, 0xf4u8, 0x04u8, - 0x0bu8, 0xfau8, 0x4fu8, 0x82u8, 0x93u8, 0x0du8, 0xe4u8, 0xbau8]) + store([0x96u8, 0x71u8, 0xfdu8, 0x4fu8, 0xcfu8, 0xbcu8, 0x06u8, 0x1cu8, + 0x93u8, 0xc2u8, 0x82u8, 0x48u8, 0x64u8, 0xcfu8, 0x03u8, 0x12u8, + 0x4fu8, 0xfeu8, 0xe7u8, 0xccu8, 0x22u8, 0x30u8, 0x8du8, 0xe1u8, + 0x2au8, 0x7cu8, 0x82u8, 0x64u8, 0x73u8, 0xe4u8, 0x99u8, 0x06u8]) } fn list_nil_addr() -> Addr { - store([0x0eu8, 0xbeu8, 0x34u8, 0x5du8, 0xc4u8, 0x69u8, 0x17u8, 0xc8u8, - 0x24u8, 0xb6u8, 0xc3u8, 0xf6u8, 0xc4u8, 0x2bu8, 0x10u8, 0x1fu8, - 0x2au8, 0xc8u8, 0xc0u8, 0xe2u8, 0xc9u8, 0x9fu8, 0x03u8, 0x3au8, - 0x0eu8, 0xe3u8, 0xc6u8, 0x0au8, 0xcbu8, 0x9cu8, 0xd8u8, 0x4du8]) + store([0x25u8, 0x8au8, 0x73u8, 0x64u8, 0xb8u8, 0x7cu8, 0x99u8, 0xfeu8, + 0x9fu8, 0x83u8, 0xe0u8, 0x5eu8, 0x0du8, 0x05u8, 0xc9u8, 0x35u8, + 0x60u8, 0x9au8, 0x0du8, 0xc5u8, 0xdfu8, 0x8du8, 0x77u8, 0x93u8, + 0x91u8, 0x30u8, 0xefu8, 0xe5u8, 0xe0u8, 0xefu8, 0xcau8, 0x3eu8]) } fn list_cons_addr() -> Addr { - store([0xf7u8, 0x98u8, 0x42u8, 0xf1u8, 0x02u8, 0x06u8, 0x59u8, 0x89u8, - 0x29u8, 0xe6u8, 0xbau8, 0x60u8, 0xceu8, 0x3eu8, 0xbau8, 0xa0u8, - 0x0du8, 0x11u8, 0xf2u8, 0x01u8, 0xc9u8, 0x9eu8, 0x80u8, 0x28u8, - 0x5fu8, 0x46u8, 0xccu8, 0x0eu8, 0x90u8, 0x93u8, 0x28u8, 0x32u8]) + store([0x77u8, 0xd5u8, 0x19u8, 0x25u8, 0x9eu8, 0xc9u8, 0xfau8, 0x48u8, + 0x9du8, 0xbeu8, 0x0eu8, 0x3du8, 0xc0u8, 0xb9u8, 0x35u8, 0x2au8, + 0xefu8, 0x34u8, 0x9cu8, 0xcdu8, 0xaau8, 0x73u8, 0xeau8, 0x58u8, + 0xb0u8, 0x8bu8, 0xb0u8, 0xbcu8, 0x68u8, 0x35u8, 0x02u8, 0xa0u8]) } fn bool_true_addr() -> Addr { - store([0x42u8, 0x0du8, 0xeau8, 0xd2u8, 0x16u8, 0x8au8, 0xbdu8, 0x16u8, - 0xa7u8, 0x05u8, 0x0eu8, 0xdfu8, 0xd8u8, 0xe1u8, 0x7du8, 0x45u8, - 0x15u8, 0x52u8, 0x37u8, 0xd3u8, 0x11u8, 0x87u8, 0x82u8, 0xd0u8, - 0xe6u8, 0x8bu8, 0x6du8, 0xe8u8, 0x77u8, 0x42u8, 0xcbu8, 0x8du8]) + store([0xa2u8, 0x9au8, 0x63u8, 0x61u8, 0x76u8, 0xcfu8, 0x11u8, 0x35u8, + 0xd0u8, 0x77u8, 0xebu8, 0x07u8, 0x47u8, 0x98u8, 0xf9u8, 0x00u8, + 0x7cu8, 0x78u8, 0xe7u8, 0x80u8, 0x13u8, 0x83u8, 0xe9u8, 0xcfu8, + 0xf3u8, 0x63u8, 0xbau8, 0xe5u8, 0xedu8, 0xf0u8, 0x57u8, 0x62u8]) } fn bool_false_addr() -> Addr { - store([0xc1u8, 0x27u8, 0xf8u8, 0x9fu8, 0x92u8, 0xe0u8, 0x48u8, 0x1fu8, - 0x7au8, 0x3eu8, 0x06u8, 0x31u8, 0xc5u8, 0x61u8, 0x5fu8, 0xe7u8, - 0xf6u8, 0xcbu8, 0xbfu8, 0x43u8, 0x9du8, 0x5fu8, 0xd7u8, 0xebu8, - 0xa4u8, 0x00u8, 0xfbu8, 0x06u8, 0x03u8, 0xaeu8, 0xdfu8, 0x2fu8]) + store([0xddu8, 0xa1u8, 0x2bu8, 0xcbu8, 0x33u8, 0x07u8, 0x27u8, 0xf6u8, + 0xdfu8, 0xb8u8, 0x16u8, 0xbcu8, 0x97u8, 0x52u8, 0xaau8, 0xbdu8, + 0x05u8, 0x20u8, 0xe6u8, 0x51u8, 0x5bu8, 0x79u8, 0xfcu8, 0x8au8, + 0x5au8, 0x9eu8, 0x71u8, 0x38u8, 0x66u8, 0xf4u8, 0xc6u8, 0x3eu8]) } -- Mirror: BigUint::succ. Increment a KLimbs by 1; ripple carry. diff --git a/Ix/IxVM/Kernel/Whnf.lean b/Ix/IxVM/Kernel/Whnf.lean index 639f82df..4c91acee 100644 --- a/Ix/IxVM/Kernel/Whnf.lean +++ b/Ix/IxVM/Kernel/Whnf.lean @@ -767,13 +767,15 @@ def whnf := ⟦ KConstantInfo.Ctor(_, _, induct_idx, _, _, _, _) => let ind_ci = load(list_lookup(top, induct_idx)); match ind_ci { - KConstantInfo.Induct(_, _, _, n_indices, ctor_indices, is_rec, _, _, _, _) => + KConstantInfo.Induct(_, _, _, n_indices, ctor_indices, _, _) => let n_ctors = list_length(ctor_indices); match n_ctors { 1 => match n_indices { 0 => - match is_rec { + -- is_rec is computed on demand (the recr flag was + -- dropped from Ixon); memoized per induct_idx. + match computed_is_rec_ind(induct_idx, top) { 0 => let major = list_lookup(spine, major_idx); let major_ty = k_infer(major, types, top, addrs); @@ -927,7 +929,7 @@ def whnf := ⟦ KConstantInfo.Ctor(_, _, induct_idx, _, _, _, _) => let ind_ci = load(list_lookup(top, induct_idx)); match ind_ci { - KConstantInfo.Induct(_, _, _, _, ctor_indices, _, _, _, _, _) => + KConstantInfo.Induct(_, _, _, _, ctor_indices, _, _) => let n_ctors = list_length(ctor_indices); match n_ctors { 0 => (0, store(KExprNode.BVar(0))), diff --git a/Ix/IxVM/KernelTypes.lean b/Ix/IxVM/KernelTypes.lean index 9f0151cc..6b8820e3 100644 --- a/Ix/IxVM/KernelTypes.lean +++ b/Ix/IxVM/KernelTypes.lean @@ -128,7 +128,10 @@ def kernelTypes := ⟦ -- CIOpaque: (num_levels, type, value, is_unsafe) -- CIQuot: (num_levels, type, kind) -- CIInduct: (num_levels, type, num_params, num_indices, - -- ctor_indices, is_rec, is_reflexive, is_unsafe, nested) + -- ctor_indices, is_unsafe) + -- The recr/refl/nested flags were dropped from Ixon (derivable from + -- constructor structure; trusting declared values was an adversarial + -- surface). is_rec is computed on demand via `compute_is_rec`. -- CICtor: (num_levels, type, induct_idx, cidx, -- num_params, num_fields, is_unsafe) -- CIRec: (num_levels, type, num_params, num_indices, @@ -143,7 +146,7 @@ def kernelTypes := ⟦ Thm(G, KExpr, KExpr), Opaque(G, KExpr, KExpr, G), Quot(G, KExpr, QuotKind), - Induct(G, KExpr, G, G, List‹G›, G, G, G, G, Addr), + Induct(G, KExpr, G, G, List‹G›, G, Addr), Ctor(G, KExpr, G, G, G, G, G), Rec(G, KExpr, G, G, G, G, List‹KRecRule›, G, G, Addr) } diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index bb234c3d..59c1e7d2 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -122,56 +122,72 @@ public def kernelCheck (name : Lean.Name) (env : Lean.Environment) : observed cost in the message so it can be pasted back. -/ private def kernelCheckEntries : List (String × Nat) := [ -- Stdlib - ("HEq", 1_713_377), - ("HEq.rec", 2_674_051), - ("Eq.rec", 2_569_332), - ("Nat", 1_856_206), - ("Nat.add", 12_914_350), - ("Nat.add_comm", 53_942_913), - ("Nat.decEq", 68_100_321), - ("Nat.decLe", 189_439_889), - ("Nat.sub_le_of_le_add", 510_322_250), + ("HEq", 1_696_277), + ("HEq.rec", 2_660_559), + ("Eq.rec", 2_556_021), + ("Nat", 1_838_794), + ("Nat.add", 12_870_219), + ("Nat.add_comm", 53_798_540), + ("Nat.decEq", 67_509_881), + ("Nat.decLe", 188_576_447), + ("Nat.sub_le_of_le_add", 509_824_193), -- Newly-unlocked targets (level_leq Géran normalize). - ("Trans.mk", 2_846_339), - ("Array.append_assoc", 2_533_821_272), - ("Vector.append", 2_604_133_144), + ("Trans.mk", 2_828_880), + ("Array.append_assoc", 2_526_945_883), + ("Vector.append", 2_595_348_010), -- Primitive reduction theorems (`IxVMPrim`) - ("IxVMPrim.nat_add_lit", 27_892_805), - ("IxVMPrim.nat_sub_lit", 33_497_103), - ("IxVMPrim.nat_mul_lit", 24_497_355), - ("IxVMPrim.nat_mul_big", 24_000_008), - ("IxVMPrim.nat_div_lit", 363_389_222), - ("IxVMPrim.nat_mod_lit", 372_071_049), - ("IxVMPrim.nat_succ_lit", 7_291_627), - ("IxVMPrim.nat_pred_lit", 14_654_475), - ("IxVMPrim.nat_gcd_lit", 599_154_968), - ("IxVMPrim.nat_land_lit", 1_008_609_362), - ("IxVMPrim.nat_lor_lit", 1_009_412_171), - ("IxVMPrim.nat_xor_lit", 1_018_002_203), - ("IxVMPrim.nat_shl_lit", 34_588_777), - ("IxVMPrim.nat_shr_lit", 368_724_780), - ("IxVMPrim.nat_pow_big", 71_440_906), - ("IxVMPrim.nat_beq_lit", 24_004_071), - ("IxVMPrim.nat_ble_lit", 22_333_685), - ("IxVMPrim.nat_dec_le", 195_966_871), - ("IxVMPrim.nat_dec_lt", 199_909_846), - ("IxVMPrim.nat_dec_eq", 81_745_967), - ("IxVMPrim.str_size_lit", 715_819_988), - ("IxVMPrim.bv_to_nat_lit", 570_787_308), + ("IxVMPrim.nat_add_lit", 27_637_857), + ("IxVMPrim.nat_sub_lit", 33_385_419), + ("IxVMPrim.nat_mul_lit", 24_394_797), + ("IxVMPrim.nat_mul_big", 23_838_327), + ("IxVMPrim.nat_div_lit", 362_960_268), + ("IxVMPrim.nat_mod_lit", 371_196_326), + ("IxVMPrim.nat_succ_lit", 7_223_234), + ("IxVMPrim.nat_pred_lit", 14_513_542), + ("IxVMPrim.nat_gcd_lit", 597_735_811), + ("IxVMPrim.nat_land_lit", 1_006_503_401), + ("IxVMPrim.nat_lor_lit", 1_007_225_060), + ("IxVMPrim.nat_xor_lit", 1_015_339_126), + ("IxVMPrim.nat_shl_lit", 34_423_639), + ("IxVMPrim.nat_shr_lit", 367_918_664), + ("IxVMPrim.nat_pow_big", 71_297_878), + ("IxVMPrim.nat_beq_lit", 23_859_376), + ("IxVMPrim.nat_ble_lit", 22_158_417), + ("IxVMPrim.nat_dec_le", 195_022_086), + ("IxVMPrim.nat_dec_lt", 198_963_907), + ("IxVMPrim.nat_dec_eq", 81_012_993), + ("IxVMPrim.str_size_lit", 712_334_245), + ("IxVMPrim.bv_to_nat_lit", 569_570_268), -- Mutual block + multi-member recursors - ("IxVMInd.Even", 25_782_627), - ("IxVMInd.Odd", 25_543_047), - ("IxVMInd.Even.rec", 31_353_084), - ("IxVMInd.Odd.rec", 31_352_181), + ("IxVMInd.Even", 25_606_681), + ("IxVMInd.Odd", 25_359_159), + ("IxVMInd.Even.rec", 31_141_424), + ("IxVMInd.Odd.rec", 31_138_920), -- Nested inductive + aux recursor (Tree.mk : List Tree → Tree) - ("IxVMInd.Tree", 2_634_029), - ("IxVMInd.Tree.rec", 4_860_101), + ("IxVMInd.Tree", 2_615_058), + ("IxVMInd.Tree.rec", 4_845_820), -- Edge cases from prelude - ("String.Internal.append", 707_285_467), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_063_219_586), + ("String.Internal.append", 704_687_418), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_059_246_298), -- Aux recursor with transitively-nested inductives (Syntax → Array Syntax -- → List Syntax); shard 53 regression driver. - ("Lean.Syntax.rec", 734_818_705), + ("Lean.Syntax.rec", 730_451_588), + -- Evaporated-aux canonicalization (Tests/Ix/Compile/Mutual.lean AuxDedup*): + -- SCC splitting strands `rec_N` auxes whose spec-param inductives moved to + -- other SCCs; their claims alias the external inductive's recursor + -- (`List.rec`) — hence the identical pin on all four evaporated entries, + -- whose claims are literally the same `List.rec` closure. AuxDedupMixed + -- mixes one genuine canonical aux (`M.rec_1`, over `List M`) with one + -- evaporated alias (`M.rec_2`, over `List B`). + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 3_524_532), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 4_412_424), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 3_073_003), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 3_073_003), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 3_073_003), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 3_557_470), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 6_164_616), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 6_166_583), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 3_073_003), ] private def nameOfString (str : String) : Lean.Name := diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index 96950f22..705ffae2 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -4818,7 +4818,7 @@ fn aiur_fn_26( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_0]; 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_739] = { let __args: [G; IN_739] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __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]; @@ -4976,10 +4976,10 @@ fn aiur_fn_26( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_0]; 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_739] = { let __args: [G; IN_739] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_0]; 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_739] = { let __args: [G; IN_739] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __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]; @@ -6680,7 +6680,7 @@ fn aiur_fn_30( let __v_1: G = G::from_u64(42); let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -6688,13 +6688,13 @@ fn aiur_fn_30( let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = G::from_u64(5); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __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_732] = { let __args: [G; IN_732] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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(10); let __v_13: G = G::from_u64(100); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_12, __v_13, __v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_12, __v_13, __v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -6703,7 +6703,7 @@ fn aiur_fn_30( let __v_21: G = __r_arr[5]; let __v_22: G = G::from_u64(20); let __v_23: G = G::from_u64(200); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = __r_arr[2]; @@ -6712,7 +6712,7 @@ fn aiur_fn_30( let __v_29: G = __r_arr[5]; let __v_30: G = G::from_u64(5); let __v_31: G = G::from_u64(50); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_30, __v_31, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_30, __v_31, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; @@ -6720,19 +6720,19 @@ fn aiur_fn_30( let __v_36: G = __r_arr[4]; let __v_37: G = __r_arr[5]; let __v_38: G = G::from_u64(5); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_732] = { let __args: [G; IN_732] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_39: G = __r_arr[0]; let __v_40: G = G::from_u64(10); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_732] = { let __args: [G; IN_732] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_41: G = __r_arr[0]; let __v_42: G = G::from_u64(20); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_732] = { let __args: [G; IN_732] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_43: G = __r_arr[0]; let __v_44: G = G::from_u64(10); let __v_45: G = G::from_u64(100); let __v_46: G = G::from_u64(1); let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_44, __v_45, __v_46, __v_47, __v_47, __v_47, __v_47, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_44, __v_45, __v_46, __v_47, __v_47, __v_47, __v_47, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -6741,7 +6741,7 @@ fn aiur_fn_30( let __v_53: G = __r_arr[5]; let __v_54: G = G::from_u64(10); let __v_55: G = G::from_u64(999); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_54, __v_55, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_54, __v_55, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -6749,13 +6749,13 @@ fn aiur_fn_30( let __v_60: G = __r_arr[4]; let __v_61: G = __r_arr[5]; let __v_62: G = G::from_u64(10); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; 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_732] = { let __args: [G; IN_732] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; 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_63: G = __r_arr[0]; let __v_64: G = G::from_u64(1); let __v_65: G = G::from_u64(10); let __v_66: G = G::from_u64(1); let __v_67: G = G::from_u64(1); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_65, __v_66, __v_67, __v_67, __v_67, __v_67, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_64, __v_65, __v_66, __v_67, __v_67, __v_67, __v_67, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = __r_arr[2]; @@ -6764,7 +6764,7 @@ fn aiur_fn_30( let __v_73: G = __r_arr[5]; let __v_74: G = G::from_u64(2); let __v_75: G = G::from_u64(20); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_74, __v_75, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_74, __v_75, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __v_78: G = __r_arr[2]; @@ -6773,7 +6773,7 @@ fn aiur_fn_30( let __v_81: G = __r_arr[5]; let __v_82: G = G::from_u64(3); let __v_83: G = G::from_u64(30); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_82, __v_83, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_82, __v_83, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; @@ -6782,7 +6782,7 @@ fn aiur_fn_30( let __v_89: G = __r_arr[5]; let __v_90: G = G::from_u64(4); let __v_91: G = G::from_u64(40); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_90, __v_91, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_90, __v_91, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; let __v_93: G = __r_arr[1]; let __v_94: G = __r_arr[2]; @@ -6791,7 +6791,7 @@ fn aiur_fn_30( let __v_97: G = __r_arr[5]; let __v_98: G = G::from_u64(5); let __v_99: G = G::from_u64(50); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_98, __v_99, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_98, __v_99, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __r_arr[2]; @@ -6799,25 +6799,25 @@ fn aiur_fn_30( let __v_104: G = __r_arr[4]; let __v_105: G = __r_arr[5]; let __v_106: G = G::from_u64(1); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_732] = { let __args: [G; IN_732] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_107: G = __r_arr[0]; let __v_108: G = G::from_u64(2); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_732] = { let __args: [G; IN_732] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_109: G = __r_arr[0]; let __v_110: G = G::from_u64(3); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_732] = { let __args: [G; IN_732] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_111: G = __r_arr[0]; let __v_112: G = G::from_u64(4); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_732] = { let __args: [G; IN_732] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_113: G = __r_arr[0]; let __v_114: G = G::from_u64(5); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_732] = { let __args: [G; IN_732] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; 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_115: G = __r_arr[0]; let __v_116: G = G::from_u64(5); let __v_117: G = G::from_u64(50); let __v_118: G = G::from_u64(1); let __v_119: G = G::from_u64(1); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_116, __v_117, __v_118, __v_119, __v_119, __v_119, __v_119, __v_119]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_116, __v_117, __v_118, __v_119, __v_119, __v_119, __v_119, __v_119]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_120: G = __r_arr[0]; let __v_121: G = __r_arr[1]; let __v_122: G = __r_arr[2]; @@ -6826,7 +6826,7 @@ fn aiur_fn_30( let __v_125: G = __r_arr[5]; let __v_126: G = G::from_u64(4); let __v_127: G = G::from_u64(40); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_126, __v_127, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_126, __v_127, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_128: G = __r_arr[0]; let __v_129: G = __r_arr[1]; let __v_130: G = __r_arr[2]; @@ -6835,7 +6835,7 @@ fn aiur_fn_30( let __v_133: G = __r_arr[5]; let __v_134: G = G::from_u64(3); let __v_135: G = G::from_u64(30); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_134, __v_135, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_134, __v_135, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_136: G = __r_arr[0]; let __v_137: G = __r_arr[1]; let __v_138: G = __r_arr[2]; @@ -6844,7 +6844,7 @@ fn aiur_fn_30( let __v_141: G = __r_arr[5]; let __v_142: G = G::from_u64(2); let __v_143: G = G::from_u64(20); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_142, __v_143, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_142, __v_143, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_144: G = __r_arr[0]; let __v_145: G = __r_arr[1]; let __v_146: G = __r_arr[2]; @@ -6853,7 +6853,7 @@ fn aiur_fn_30( let __v_149: G = __r_arr[5]; let __v_150: G = G::from_u64(1); let __v_151: G = G::from_u64(10); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_150, __v_151, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_150, __v_151, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_152: G = __r_arr[0]; let __v_153: G = __r_arr[1]; let __v_154: G = __r_arr[2]; @@ -6861,25 +6861,25 @@ fn aiur_fn_30( let __v_156: G = __r_arr[4]; let __v_157: G = __r_arr[5]; let __v_158: G = G::from_u64(1); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_732] = { let __args: [G; IN_732] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_159: G = __r_arr[0]; let __v_160: G = G::from_u64(2); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_732] = { let __args: [G; IN_732] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_161: G = __r_arr[0]; let __v_162: G = G::from_u64(3); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_732] = { let __args: [G; IN_732] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_163: G = __r_arr[0]; let __v_164: G = G::from_u64(4); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_732] = { let __args: [G; IN_732] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_165: G = __r_arr[0]; let __v_166: G = G::from_u64(5); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_732] = { let __args: [G; IN_732] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; 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_167: G = __r_arr[0]; let __v_168: G = G::from_u64(50); let __v_169: G = G::from_u64(500); let __v_170: G = G::from_u64(1); let __v_171: G = G::from_u64(1); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_168, __v_169, __v_170, __v_171, __v_171, __v_171, __v_171, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_168, __v_169, __v_170, __v_171, __v_171, __v_171, __v_171, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; let __v_174: G = __r_arr[2]; @@ -6888,7 +6888,7 @@ fn aiur_fn_30( let __v_177: G = __r_arr[5]; let __v_178: G = G::from_u64(30); let __v_179: G = G::from_u64(300); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_178, __v_179, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_178, __v_179, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_180: G = __r_arr[0]; let __v_181: G = __r_arr[1]; let __v_182: G = __r_arr[2]; @@ -6897,7 +6897,7 @@ fn aiur_fn_30( let __v_185: G = __r_arr[5]; let __v_186: G = G::from_u64(70); let __v_187: G = G::from_u64(700); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_186, __v_187, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_186, __v_187, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; @@ -6906,7 +6906,7 @@ fn aiur_fn_30( let __v_193: G = __r_arr[5]; let __v_194: G = G::from_u64(20); let __v_195: G = G::from_u64(200); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_194, __v_195, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_194, __v_195, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_196: G = __r_arr[0]; let __v_197: G = __r_arr[1]; let __v_198: G = __r_arr[2]; @@ -6915,7 +6915,7 @@ fn aiur_fn_30( let __v_201: G = __r_arr[5]; let __v_202: G = G::from_u64(40); let __v_203: G = G::from_u64(400); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_202, __v_203, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_202, __v_203, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_204: G = __r_arr[0]; let __v_205: G = __r_arr[1]; let __v_206: G = __r_arr[2]; @@ -6924,7 +6924,7 @@ fn aiur_fn_30( let __v_209: G = __r_arr[5]; let __v_210: G = G::from_u64(60); let __v_211: G = G::from_u64(600); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_210, __v_211, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_210, __v_211, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_212: G = __r_arr[0]; let __v_213: G = __r_arr[1]; let __v_214: G = __r_arr[2]; @@ -6933,7 +6933,7 @@ fn aiur_fn_30( let __v_217: G = __r_arr[5]; let __v_218: G = G::from_u64(80); let __v_219: G = G::from_u64(800); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_218, __v_219, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_218, __v_219, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_220: G = __r_arr[0]; let __v_221: G = __r_arr[1]; let __v_222: G = __r_arr[2]; @@ -6941,25 +6941,25 @@ fn aiur_fn_30( let __v_224: G = __r_arr[4]; let __v_225: G = __r_arr[5]; let __v_226: G = G::from_u64(20); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_732] = { let __args: [G; IN_732] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_227: G = __r_arr[0]; let __v_228: G = G::from_u64(30); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_732] = { let __args: [G; IN_732] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_229: G = __r_arr[0]; let __v_230: G = G::from_u64(40); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_732] = { let __args: [G; IN_732] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_231: G = __r_arr[0]; let __v_232: G = G::from_u64(50); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_732] = { let __args: [G; IN_732] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_233: G = __r_arr[0]; let __v_234: G = G::from_u64(60); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_732] = { let __args: [G; IN_732] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_235: G = __r_arr[0]; let __v_236: G = G::from_u64(70); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_732] = { let __args: [G; IN_732] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_237: G = __r_arr[0]; let __v_238: G = G::from_u64(80); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_732] = { let __args: [G; IN_732] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; 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_239: G = __r_arr[0]; let __ret: [G; OUT_30] = [__v_11, __v_39, __v_41, __v_43, __v_63, __v_107, __v_109, __v_111, __v_113, __v_115, __v_159, __v_161, __v_163, __v_165, __v_167, __v_227, __v_229, __v_231, __v_233, __v_235, __v_237, __v_239]; record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7014,7 +7014,7 @@ fn aiur_fn_31( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__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_722] = { let __args: [G; IN_722] = [__v_9]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7035,7 +7035,7 @@ fn aiur_fn_31( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__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_722] = { let __args: [G; IN_722] = [__v_9]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -9016,7 +9016,7 @@ fn aiur_fn_55( 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_733] = { let __args: [G; IN_733] = [__v_43]; 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_736] = { let __args: [G; IN_736] = [__v_43]; 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_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -9320,8 +9320,8 @@ fn aiur_fn_59( }) } -const INPUT_SIZE_60: usize = 38; -const IN_60: usize = 38; +const INPUT_SIZE_60: usize = 28; +const IN_60: usize = 28; const OUT_60: usize = 1; fn aiur_fn_60( inp: [G; IN_60], @@ -9358,69 +9358,51 @@ fn aiur_fn_60( let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_35.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; - let __v_38: G = __loaded[0]; - let __v_39: G = __loaded[1]; - let __v_40: G = __loaded[2]; - let __v_41: G = __loaded[3]; - let __v_42: G = __loaded[4]; - let __v_43: G = __loaded[5]; - let __v_44: G = __loaded[6]; - let __v_45: G = __loaded[7]; - let __v_46: G = __loaded[8]; - let __v_47: G = __loaded[9]; - let __v_48: G = __loaded[10]; - let __v_49: G = __loaded[11]; - let __v_50: G = __loaded[12]; - let __v_51: G = __loaded[13]; - let __v_52: G = __loaded[14]; - let __v_53: G = __loaded[15]; - let __v_54: G = __loaded[16]; - let __v_55: G = __loaded[17]; - let __v_56: G = G::from_u64(2); - let __v_57: G = (__v_56 * __v_1); - let __v_58: G = G::from_u64(4); - let __v_59: G = (__v_58 * __v_2); - let __v_60: G = (__v_57 + __v_59); - let __v_61: G = (__v_0 + __v_60); - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_36]; 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_62: G = __r_arr[0]; - let __v_63: G = __r_arr[1]; - let __v_64: G = __r_arr[2]; - let __v_65: G = __r_arr[3]; - let __v_66: G = __r_arr[4]; - let __v_67: G = __r_arr[5]; - let __v_68: G = __r_arr[6]; - let __v_69: G = __r_arr[7]; - let __v_70: G = G::from_u64(0); - let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; - let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; - let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_38, __v_39, __v_40, __v_41, __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_72]; 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_73: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; - let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; - let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; - let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; - let __v_77: G = __r_arr[0]; - let __v_78: G = { let __values: [G; 3] = [__v_70, __v_61, __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 __ret: [G; OUT_60] = [__v_78]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_28: G = __loaded[0]; + let __v_29: G = __loaded[1]; + let __v_30: G = __loaded[2]; + let __v_31: G = __loaded[3]; + let __v_32: G = __loaded[4]; + let __v_33: G = __loaded[5]; + let __v_34: G = __loaded[6]; + let __v_35: G = __loaded[7]; + let __v_36: G = __loaded[8]; + let __v_37: G = __loaded[9]; + let __v_38: G = __loaded[10]; + let __v_39: G = __loaded[11]; + let __v_40: G = __loaded[12]; + let __v_41: G = __loaded[13]; + let __v_42: G = __loaded[14]; + let __v_43: G = __loaded[15]; + let __v_44: G = __loaded[16]; + let __v_45: G = __loaded[17]; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_26]; 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 __v_47: G = __r_arr[1]; + let __v_48: G = __r_arr[2]; + let __v_49: G = __r_arr[3]; + let __v_50: G = __r_arr[4]; + let __v_51: G = __r_arr[5]; + let __v_52: G = __r_arr[6]; + let __v_53: G = __r_arr[7]; + let __v_54: G = G::from_u64(0); + let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_57: G = __r_arr[0]; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_60] = [__v_61]; record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, @@ -9576,7 +9558,7 @@ fn aiur_fn_63( 1u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_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[60].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_63] = [__v_49]; @@ -9814,7 +9796,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_720] = { let __args: [G; IN_720] = [__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_723] = { let __args: [G; IN_723] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9845,7 +9827,7 @@ fn aiur_fn_67( 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]; 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_723] = { let __args: [G; IN_723] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9876,7 +9858,7 @@ fn aiur_fn_68( 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]; 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_723] = { let __args: [G; IN_723] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9964,7 +9946,7 @@ fn aiur_fn_69( let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_1]; 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_735] = { let __args: [G; IN_735] = [__v_1]; 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_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -12520,7 +12502,7 @@ fn aiur_fn_99( const INPUT_SIZE_100: usize = 1; const IN_100: usize = 1; -const OUT_100: usize = 38; +const OUT_100: usize = 28; fn aiur_fn_100( inp: [G; IN_100], record: &mut QueryRecord, @@ -12571,7 +12553,7 @@ fn aiur_fn_100( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -12581,41 +12563,31 @@ fn aiur_fn_100( let __v_44: G = __r_arr[6]; let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; - let __v_47: G = __r_arr[0]; - let __v_48: G = __r_arr[1]; - let __v_49: G = __r_arr[2]; - let __v_50: G = __r_arr[3]; - let __v_51: G = __r_arr[4]; - let __v_52: G = __r_arr[5]; - let __v_53: G = __r_arr[6]; - let __v_54: G = __r_arr[7]; - let __v_55: G = __r_arr[8]; - let __v_56: G = __r_arr[9]; - let __v_57: G = __r_arr[10]; - let __v_58: G = __r_arr[11]; - let __v_59: G = __r_arr[12]; - let __v_60: G = __r_arr[13]; - let __v_61: G = __r_arr[14]; - let __v_62: G = __r_arr[15]; - let __v_63: G = __r_arr[16]; - let __v_64: G = __r_arr[17]; - let __v_65: G = __r_arr[18]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[9]; + let __v_48: G = __r_arr[10]; + let __v_49: G = __r_arr[11]; + let __v_50: G = __r_arr[12]; + let __v_51: G = __r_arr[13]; + let __v_52: G = __r_arr[14]; + let __v_53: G = __r_arr[15]; + let __v_54: G = __r_arr[16]; + let __v_55: G = __r_arr[17]; + let __v_56: G = __r_arr[18]; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __v_59: G = __r_arr[2]; + let __v_60: G = __r_arr[3]; + let __v_61: G = __r_arr[4]; + let __v_62: G = __r_arr[5]; + let __v_63: G = __r_arr[6]; + let __v_64: G = __r_arr[7]; + let __v_65: G = __r_arr[8]; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; - let __v_68: G = __r_arr[2]; - let __v_69: G = __r_arr[3]; - let __v_70: G = __r_arr[4]; - let __v_71: G = __r_arr[5]; - let __v_72: G = __r_arr[6]; - let __v_73: G = __r_arr[7]; - let __v_74: G = __r_arr[8]; - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_74, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; - let __v_75: G = __r_arr[0]; - let __v_76: G = __r_arr[1]; - let __v_77: G = { let __values: [G; 18] = [__v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&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_100] = [__v_3, __v_4, __v_5, __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_77, __v_75, __v_76]; + let __v_68: G = { let __values: [G; 18] = [__v_38, __v_39, __v_40, __v_41, __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]; 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_100] = [__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_68, __v_66, __v_67]; record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) @@ -12757,19 +12729,9 @@ fn aiur_fn_103( let __v_28: G = __r_arr[25]; let __v_29: G = __r_arr[26]; let __v_30: G = __r_arr[27]; - let __v_31: G = __r_arr[28]; - let __v_32: G = __r_arr[29]; - let __v_33: G = __r_arr[30]; - let __v_34: G = __r_arr[31]; - let __v_35: G = __r_arr[32]; - let __v_36: G = __r_arr[33]; - let __v_37: G = __r_arr[34]; - let __v_38: G = __r_arr[35]; - let __v_39: G = __r_arr[36]; - let __v_40: G = __r_arr[37]; - let __v_41: G = G::from_u64(1); - let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_103] = [__v_41, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + let __v_31: G = G::from_u64(1); + let __v_32: G = G::from_u64(0); + let __ret: [G; OUT_103] = [__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[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, @@ -13434,7 +13396,7 @@ fn aiur_fn_109( 0u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_12]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_12]; 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(0); 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)? } }; @@ -13789,7 +13751,7 @@ fn aiur_fn_113( 0u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_24]; 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_729] = { let __args: [G; IN_729] = [__v_5, __v_24]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_25]; 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)? } }; @@ -13813,7 +13775,7 @@ fn aiur_fn_113( 2u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_24]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __v_5]; 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_26: G = __r_arr[0]; @@ -13827,7 +13789,7 @@ fn aiur_fn_113( 3u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_24]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_24]; 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_25: G = __r_arr[0]; let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __v_5]; 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_26: G = __r_arr[0]; @@ -13841,7 +13803,7 @@ fn aiur_fn_113( 4u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_24]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_24]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(8); let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; 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)? } }; @@ -13854,7 +13816,7 @@ fn aiur_fn_113( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __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[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_730] = { let __args: [G; IN_730] = [__v_4, __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[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_24: G = __r_arr[0]; let __v_25: G = G::from_u64(7); let __v_26: G = G::from_u64(1); @@ -13865,7 +13827,7 @@ fn aiur_fn_113( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __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[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_730] = { let __args: [G; IN_730] = [__v_4, __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[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_24: G = __r_arr[0]; let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_24]; 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_25: G = __r_arr[0]; @@ -13929,7 +13891,7 @@ fn aiur_fn_113( 11u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_25: 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_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; @@ -14302,8 +14264,8 @@ fn aiur_fn_118( }) } -const INPUT_SIZE_119: usize = 44; -const IN_119: usize = 44; +const INPUT_SIZE_119: usize = 34; +const IN_119: usize = 34; const OUT_119: usize = 11; fn aiur_fn_119( inp: [G; IN_119], @@ -14346,32 +14308,21 @@ fn aiur_fn_119( let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - match __v_37.as_canonical_u64() { + match __v_27.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_35, __v_37, __v_38, __v_39, __v_40, __v_41]; 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 __v_45: G = G::from_u64(5); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_46: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !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_47: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_48: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; 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_49: G = __r_arr[0]; - let __ret: [G; OUT_119] = [__v_45, __v_46, __v_44, __v_47, __v_48, __v_42, __v_0, __v_1, __v_2, __v_49, __v_43]; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_25, __v_27, __v_28, __v_29, __v_30, __v_31]; 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_34: G = __r_arr[0]; + let __v_35: G = G::from_u64(5); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_36: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !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_37: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_38: G = __r_arr[0]; + let __v_39: G = G::from_u64(0); + let __ret: [G; OUT_119] = [__v_35, __v_36, __v_34, __v_37, __v_38, __v_32, __v_0, __v_33, __v_39, __v_39, __v_39]; record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, @@ -14593,7 +14544,7 @@ fn aiur_fn_121( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_1, __v_2, __v_3, __v_4, __v_5, __v_44, __v_45]; 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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_1, __v_2, __v_3, __v_4, __v_5, __v_34, __v_35]; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; @@ -15825,7 +15776,7 @@ fn aiur_fn_130( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); let __v_47: G = (__v_45 + __v_46); @@ -16049,7 +16000,7 @@ fn aiur_fn_133( let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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_726] = { let __args: [G; IN_726] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { @@ -16179,7 +16130,7 @@ fn aiur_fn_135( let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_3, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_3, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -16337,13 +16288,13 @@ fn aiur_fn_137( }, 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_10]; 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_726] = { let __args: [G; IN_726] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_10]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = []; 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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_8, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_8, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; @@ -16444,7 +16395,7 @@ fn aiur_fn_139( let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_9, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_9, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -16494,7 +16445,7 @@ fn aiur_fn_140( let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_726] = { let __args: [G; IN_726] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_9: G = __r_arr[0]; let __ret: [G; OUT_140] = [__v_9]; record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -17721,7 +17672,7 @@ fn aiur_fn_149( let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_5, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; 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_726] = { let __args: [G; IN_726] = [__v_5, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { @@ -18104,7 +18055,7 @@ fn aiur_fn_154( let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __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_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_20, __v_17, __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_743] = { let __args: [G; IN_743] = [__v_11, __v_17, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_11, __v_17, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; @@ -18202,7 +18153,7 @@ fn aiur_fn_156( let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; 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_726] = { let __args: [G; IN_726] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __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_14: G = __r_arr[0]; let __ret: [G; OUT_156] = [__v_14]; record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18458,7 +18409,7 @@ fn aiur_fn_161( 1u64 => { match __v_4.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_49, __v_1, __v_50]; 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)? } }; @@ -18468,7 +18419,7 @@ fn aiur_fn_161( let __v_54: G = (__v_1 + __v_53); let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_48, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_51, __v_55]; 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_724] = { let __args: [G; IN_724] = [__v_51, __v_55]; 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_56: G = __r_arr[0]; let __ret: [G; OUT_161] = [__v_56]; record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18629,7 +18580,7 @@ fn aiur_fn_163( 11u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_20: 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_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -19039,7 +18990,7 @@ fn aiur_fn_166( 2u64 => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[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_75: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_19, __v_75]; 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_729] = { let __args: [G; IN_729] = [__v_19, __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 __ret: [G; OUT_166] = [__v_76]; record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -19461,7 +19412,7 @@ fn aiur_fn_169( 1u64 => { match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(0); let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_54, __v_1, __v_55]; 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)? } }; @@ -19575,7 +19526,7 @@ fn aiur_fn_170( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; @@ -19585,10 +19536,10 @@ fn aiur_fn_170( let __v_61: G = __r_arr[0]; let __v_62: G = G::from_u64(4); let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_37, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_27, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(0); - let __v_66: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_62, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_61, __v_56, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_62, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_61, __v_56, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_170] = [__v_67]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -19832,7 +19783,7 @@ fn aiur_fn_172( let __v_62: G = (__v_8 + __v_61); let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_59, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_62, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_60, __v_63]; 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_724] = { let __args: [G; IN_724] = [__v_60, __v_63]; 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_64: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_64]; record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20059,7 +20010,7 @@ fn aiur_fn_175( let __v_74: G = (__v_7 + __v_65); let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_74, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_73, __v_75]; 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_724] = { let __args: [G; IN_724] = [__v_73, __v_75]; 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_76: G = __r_arr[0]; let __ret: [G; OUT_175] = [__v_76]; record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20221,7 +20172,7 @@ fn aiur_fn_176( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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_726] = { let __args: [G; IN_726] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -20332,7 +20283,7 @@ fn aiur_fn_176( let __v_53: G = G::from_u64(0); let __v_54: G = { let __values: [G; 3] = [__v_53, __v_0, __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_55: G = G::from_u64(1); - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0, __v_55, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0, __v_55, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -20435,9 +20386,9 @@ fn aiur_fn_176( let __v_148: G = G::from_u64(1); let __v_149: G = G::from_u64(1); let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_108, __v_150]; 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_724] = { let __args: [G; IN_724] = [__v_108, __v_150]; 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_151: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_151, __v_1]; 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_724] = { let __args: [G; IN_724] = [__v_151, __v_1]; 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_152: 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_152.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_153: G = __loaded[0]; @@ -20468,9 +20419,9 @@ fn aiur_fn_176( let __v_150: G = G::from_u64(1); let __v_151: G = { let __values: [G; 3] = [__v_149, __v_150, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_152: G = { let __values: [G; 3] = [__v_148, __v_113, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_108, __v_152]; 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_724] = { let __args: [G; IN_724] = [__v_108, __v_152]; 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_153: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_153, __v_1]; 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_724] = { let __args: [G; IN_724] = [__v_153, __v_1]; 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_154: 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_154.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_155: G = __loaded[0]; @@ -20997,7 +20948,7 @@ fn aiur_fn_183( let __v_20: G = (__v_19 - __v_3); match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_17, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_17, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -21112,7 +21063,7 @@ fn aiur_fn_185( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_8, __v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_8, __v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -21167,7 +21118,7 @@ fn aiur_fn_186( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_726] = { let __args: [G; IN_726] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); @@ -21342,7 +21293,7 @@ fn aiur_fn_187( let __v_114: G = __r_arr[0]; let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_5, __v_56, __v_2]; 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_115: G = __r_arr[0]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_114, __v_115]; 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_737] = { let __args: [G; IN_737] = [__v_114, __v_115]; 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_116: G = __r_arr[0]; let __ret: [G; OUT_187] = [__v_116]; record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21481,7 +21432,7 @@ fn aiur_fn_189( 1u64 => { match __v_5.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_189] = [__v_51]; record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21798,9 +21749,9 @@ fn aiur_fn_194( 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_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_25, __v_74]; 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_724] = { let __args: [G; IN_724] = [__v_25, __v_74]; 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_76: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_73, __v_75]; 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_724] = { let __args: [G; IN_724] = [__v_73, __v_75]; 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_77: G = __r_arr[0]; let __ret: [G; OUT_194] = [__v_76, __v_77]; record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -22231,7 +22182,7 @@ fn aiur_fn_199( let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __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_721] = { let __args: [G; IN_721] = [__v_6, __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_7: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_5, __v_7]; record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24798,7 +24749,7 @@ fn aiur_fn_230( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_5: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_5]; record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25353,38 +25304,38 @@ fn aiur_fn_239( unconstrained: bool, ) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(170); - let __v_1: G = G::from_u64(87); - let __v_2: G = G::from_u64(232); - let __v_3: G = G::from_u64(195); - let __v_4: G = G::from_u64(244); - let __v_5: G = G::from_u64(249); - let __v_6: G = G::from_u64(225); - let __v_7: G = G::from_u64(207); - let __v_8: G = G::from_u64(107); - let __v_9: G = G::from_u64(2); - let __v_10: G = G::from_u64(160); - let __v_11: G = G::from_u64(56); - let __v_12: G = G::from_u64(172); - let __v_13: G = G::from_u64(21); - let __v_14: G = G::from_u64(129); - let __v_15: G = G::from_u64(152); - let __v_16: G = G::from_u64(195); - let __v_17: G = G::from_u64(175); - let __v_18: G = G::from_u64(75); - let __v_19: G = G::from_u64(40); - let __v_20: G = G::from_u64(214); - let __v_21: G = G::from_u64(28); - let __v_22: G = G::from_u64(234); - let __v_23: G = G::from_u64(121); - let __v_24: G = G::from_u64(149); - let __v_25: G = G::from_u64(191); - let __v_26: G = G::from_u64(92); - let __v_27: G = G::from_u64(167); - let __v_28: G = G::from_u64(199); - let __v_29: G = G::from_u64(184); - let __v_30: G = G::from_u64(44); - let __v_31: G = G::from_u64(41); + let __v_0: G = G::from_u64(141); + let __v_1: G = G::from_u64(196); + let __v_2: G = G::from_u64(169); + let __v_3: G = G::from_u64(117); + let __v_4: G = G::from_u64(39); + let __v_5: G = G::from_u64(129); + let __v_6: G = G::from_u64(47); + let __v_7: G = G::from_u64(139); + let __v_8: G = G::from_u64(120); + let __v_9: G = G::from_u64(23); + let __v_10: G = G::from_u64(183); + let __v_11: G = G::from_u64(124); + let __v_12: G = G::from_u64(208); + let __v_13: G = G::from_u64(121); + let __v_14: G = G::from_u64(172); + let __v_15: G = G::from_u64(230); + let __v_16: G = G::from_u64(20); + let __v_17: G = G::from_u64(80); + let __v_18: G = G::from_u64(170); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(133); + let __v_21: G = G::from_u64(172); + let __v_22: G = G::from_u64(88); + let __v_23: G = G::from_u64(133); + let __v_24: G = G::from_u64(102); + let __v_25: G = G::from_u64(30); + let __v_26: G = G::from_u64(194); + let __v_27: G = G::from_u64(172); + let __v_28: G = G::from_u64(186); + 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_239] = [__v_32]; record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25451,38 +25402,38 @@ fn aiur_fn_241( unconstrained: bool, ) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(51); - let __v_1: G = G::from_u64(217); - let __v_2: G = G::from_u64(74); - let __v_3: G = G::from_u64(45); - let __v_4: G = G::from_u64(37); - let __v_5: G = G::from_u64(10); - let __v_6: G = G::from_u64(26); - let __v_7: G = G::from_u64(90); - let __v_8: G = G::from_u64(160); - let __v_9: G = G::from_u64(34); - let __v_10: G = G::from_u64(227); - let __v_11: G = G::from_u64(190); - let __v_12: G = G::from_u64(253); - let __v_13: G = G::from_u64(202); - let __v_14: G = G::from_u64(28); - let __v_15: G = G::from_u64(134); - let __v_16: G = G::from_u64(244); - let __v_17: G = G::from_u64(93); - let __v_18: G = G::from_u64(112); - let __v_19: G = G::from_u64(7); - let __v_20: G = G::from_u64(29); - let __v_21: G = G::from_u64(176); - let __v_22: G = G::from_u64(56); - let __v_23: G = G::from_u64(239); - let __v_24: G = G::from_u64(249); - let __v_25: G = G::from_u64(184); - let __v_26: G = G::from_u64(152); - let __v_27: G = G::from_u64(13); - let __v_28: G = G::from_u64(197); - let __v_29: G = G::from_u64(22); - let __v_30: G = G::from_u64(11); - let __v_31: G = G::from_u64(118); + 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)); __ptr } }; let __ret: [G; OUT_241] = [__v_32]; record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25500,38 +25451,38 @@ fn aiur_fn_242( unconstrained: bool, ) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(249); - let __v_1: G = G::from_u64(66); - let __v_2: G = G::from_u64(113); - let __v_3: G = G::from_u64(72); - let __v_4: G = G::from_u64(47); - let __v_5: G = G::from_u64(253); - let __v_6: G = G::from_u64(253); - let __v_7: G = G::from_u64(120); - let __v_8: G = G::from_u64(2); - let __v_9: G = G::from_u64(212); - let __v_10: G = G::from_u64(46); - let __v_11: G = G::from_u64(34); - let __v_12: G = G::from_u64(39); - let __v_13: G = G::from_u64(28); - let __v_14: G = G::from_u64(137); - let __v_15: G = G::from_u64(226); - let __v_16: G = G::from_u64(29); - let __v_17: G = G::from_u64(238); - let __v_18: G = G::from_u64(69); - let __v_19: G = G::from_u64(107); - let __v_20: G = G::from_u64(5); - let __v_21: G = G::from_u64(8); - let __v_22: G = G::from_u64(89); - let __v_23: G = G::from_u64(197); - let __v_24: G = G::from_u64(209); - let __v_25: G = G::from_u64(46); - let __v_26: G = G::from_u64(61); - let __v_27: G = G::from_u64(29); - let __v_28: G = G::from_u64(105); - let __v_29: G = G::from_u64(155); - let __v_30: G = G::from_u64(180); - let __v_31: G = G::from_u64(234); + 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)); __ptr } }; let __ret: [G; OUT_242] = [__v_32]; record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25549,38 +25500,38 @@ fn aiur_fn_243( unconstrained: bool, ) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(42); - let __v_1: G = G::from_u64(203); - let __v_2: G = G::from_u64(137); - let __v_3: G = G::from_u64(66); - let __v_4: G = G::from_u64(243); - let __v_5: G = G::from_u64(88); - let __v_6: G = G::from_u64(125); - let __v_7: G = G::from_u64(10); - let __v_8: G = G::from_u64(235); - let __v_9: G = G::from_u64(241); - let __v_10: G = G::from_u64(121); - let __v_11: G = G::from_u64(93); - let __v_12: G = G::from_u64(249); - let __v_13: G = G::from_u64(4); - let __v_14: G = G::from_u64(38); - let __v_15: G = G::from_u64(234); - let __v_16: G = G::from_u64(255); - let __v_17: G = G::from_u64(84); - let __v_18: G = G::from_u64(231); - let __v_19: G = G::from_u64(243); - let __v_20: G = G::from_u64(204); - let __v_21: G = G::from_u64(206); - let __v_22: G = G::from_u64(54); - let __v_23: G = G::from_u64(197); - let __v_24: G = G::from_u64(137); - let __v_25: G = G::from_u64(213); - let __v_26: G = G::from_u64(209); - let __v_27: G = G::from_u64(71); - let __v_28: G = G::from_u64(22); - let __v_29: G = G::from_u64(167); - let __v_30: G = G::from_u64(143); - let __v_31: G = G::from_u64(173); + 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)); __ptr } }; let __ret: [G; OUT_243] = [__v_32]; record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25598,38 +25549,38 @@ fn aiur_fn_244( unconstrained: bool, ) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(6); - let __v_1: G = G::from_u64(138); - let __v_2: G = G::from_u64(136); - let __v_3: G = G::from_u64(65); - let __v_4: G = G::from_u64(14); - let __v_5: G = G::from_u64(244); - let __v_6: G = G::from_u64(69); - let __v_7: G = G::from_u64(211); - let __v_8: G = G::from_u64(26); - let __v_9: G = G::from_u64(229); - let __v_10: G = G::from_u64(142); - let __v_11: G = G::from_u64(14); - let __v_12: G = G::from_u64(17); - let __v_13: G = G::from_u64(179); - let __v_14: G = G::from_u64(104); - let __v_15: G = G::from_u64(65); - let __v_16: G = G::from_u64(67); - let __v_17: G = G::from_u64(228); - let __v_18: G = G::from_u64(114); - let __v_19: G = G::from_u64(40); - let __v_20: G = G::from_u64(139); - let __v_21: G = G::from_u64(212); - let __v_22: G = G::from_u64(168); - let __v_23: G = G::from_u64(132); - let __v_24: G = G::from_u64(213); - let __v_25: G = G::from_u64(249); - let __v_26: G = G::from_u64(40); - let __v_27: G = G::from_u64(195); - let __v_28: G = G::from_u64(210); - let __v_29: G = G::from_u64(1); - let __v_30: G = G::from_u64(155); - let __v_31: G = G::from_u64(236); + 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)); __ptr } }; let __ret: [G; OUT_244] = [__v_32]; record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25647,38 +25598,38 @@ fn aiur_fn_245( unconstrained: bool, ) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(244); - let __v_1: G = G::from_u64(205); - let __v_2: G = G::from_u64(188); - let __v_3: G = G::from_u64(94); - let __v_4: G = G::from_u64(217); - let __v_5: G = G::from_u64(161); - let __v_6: G = G::from_u64(171); - let __v_7: G = G::from_u64(89); - let __v_8: G = G::from_u64(40); - let __v_9: G = G::from_u64(249); - let __v_10: G = G::from_u64(147); - let __v_11: G = G::from_u64(31); - let __v_12: G = G::from_u64(92); - let __v_13: G = G::from_u64(35); - let __v_14: G = G::from_u64(144); - let __v_15: G = G::from_u64(35); - let __v_16: G = G::from_u64(158); - let __v_17: G = G::from_u64(127); - let __v_18: G = G::from_u64(71); - let __v_19: G = G::from_u64(223); - let __v_20: G = G::from_u64(109); - let __v_21: G = G::from_u64(32); - let __v_22: G = G::from_u64(232); - let __v_23: G = G::from_u64(78); - let __v_24: G = G::from_u64(164); - let __v_25: G = G::from_u64(101); - let __v_26: G = G::from_u64(201); - let __v_27: G = G::from_u64(112); - let __v_28: G = G::from_u64(123); - let __v_29: G = G::from_u64(132); - let __v_30: G = G::from_u64(205); - let __v_31: G = G::from_u64(193); + let __v_0: G = G::from_u64(197); + let __v_1: G = G::from_u64(247); + let __v_2: G = G::from_u64(177); + let __v_3: G = G::from_u64(150); + let __v_4: G = G::from_u64(99); + let __v_5: G = G::from_u64(228); + let __v_6: G = G::from_u64(73); + let __v_7: G = G::from_u64(158); + let __v_8: G = G::from_u64(112); + let __v_9: G = G::from_u64(225); + let __v_10: G = G::from_u64(178); + let __v_11: G = G::from_u64(100); + let __v_12: G = G::from_u64(81); + let __v_13: G = G::from_u64(98); + let __v_14: G = G::from_u64(197); + let __v_15: G = G::from_u64(190); + let __v_16: G = G::from_u64(21); + let __v_17: G = G::from_u64(250); + let __v_18: G = G::from_u64(134); + let __v_19: G = G::from_u64(15); + let __v_20: G = G::from_u64(79); + let __v_21: G = G::from_u64(129); + let __v_22: G = G::from_u64(87); + let __v_23: G = G::from_u64(227); + let __v_24: G = G::from_u64(49); + let __v_25: G = G::from_u64(174); + let __v_26: G = G::from_u64(84); + let __v_27: G = G::from_u64(108); + let __v_28: G = G::from_u64(111); + 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 __ret: [G; OUT_245] = [__v_32]; record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25696,38 +25647,38 @@ fn aiur_fn_246( unconstrained: bool, ) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(1); - let __v_1: G = G::from_u64(216); - let __v_2: G = G::from_u64(113); - let __v_3: G = G::from_u64(188); - let __v_4: G = G::from_u64(223); - let __v_5: G = G::from_u64(178); - let __v_6: G = G::from_u64(231); - let __v_7: G = G::from_u64(105); - let __v_8: G = G::from_u64(225); - let __v_9: G = G::from_u64(172); - let __v_10: G = G::from_u64(160); - let __v_11: G = G::from_u64(14); - let __v_12: G = G::from_u64(122); - let __v_13: G = G::from_u64(59); - let __v_14: G = G::from_u64(58); - let __v_15: G = G::from_u64(33); - let __v_16: G = G::from_u64(168); - let __v_17: G = G::from_u64(217); - let __v_18: G = G::from_u64(2); - let __v_19: G = G::from_u64(204); - let __v_20: G = G::from_u64(39); - let __v_21: G = G::from_u64(55); - let __v_22: G = G::from_u64(7); - let __v_23: G = G::from_u64(200); - let __v_24: G = G::from_u64(146); - let __v_25: G = G::from_u64(235); - let __v_26: G = G::from_u64(134); - let __v_27: G = G::from_u64(123); - let __v_28: G = G::from_u64(127); - let __v_29: G = G::from_u64(199); - let __v_30: G = G::from_u64(138); - let __v_31: G = G::from_u64(226); + let __v_0: G = G::from_u64(202); + let __v_1: G = G::from_u64(202); + let __v_2: G = G::from_u64(234); + let __v_3: G = G::from_u64(151); + let __v_4: G = G::from_u64(244); + let __v_5: G = G::from_u64(205); + let __v_6: G = G::from_u64(186); + let __v_7: G = G::from_u64(10); + let __v_8: G = G::from_u64(74); + let __v_9: G = G::from_u64(10); + let __v_10: G = G::from_u64(247); + let __v_11: G = G::from_u64(16); + let __v_12: G = G::from_u64(5); + let __v_13: G = G::from_u64(208); + let __v_14: G = G::from_u64(81); + let __v_15: G = G::from_u64(125); + let __v_16: G = G::from_u64(24); + let __v_17: G = G::from_u64(24); + let __v_18: G = G::from_u64(171); + let __v_19: G = G::from_u64(38); + let __v_20: G = G::from_u64(35); + let __v_21: G = G::from_u64(189); + let __v_22: G = G::from_u64(46); + let __v_23: G = G::from_u64(167); + let __v_24: G = G::from_u64(250); + let __v_25: G = G::from_u64(140); + let __v_26: G = G::from_u64(99); + let __v_27: G = G::from_u64(122); + let __v_28: G = G::from_u64(14); + 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 __ret: [G; OUT_246] = [__v_32]; record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25745,38 +25696,38 @@ fn aiur_fn_247( unconstrained: bool, ) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(100); - let __v_1: G = G::from_u64(5); - let __v_2: G = G::from_u64(164); - let __v_3: G = G::from_u64(85); - let __v_4: G = G::from_u64(186); - let __v_5: G = G::from_u64(112); - let __v_6: G = G::from_u64(194); - let __v_7: G = G::from_u64(178); - let __v_8: G = G::from_u64(23); - let __v_9: G = G::from_u64(156); - let __v_10: G = G::from_u64(121); - let __v_11: G = G::from_u64(102); - let __v_12: G = G::from_u64(198); - let __v_13: G = G::from_u64(246); - let __v_14: G = G::from_u64(16); - let __v_15: G = G::from_u64(191); - let __v_16: G = G::from_u64(52); - let __v_17: G = G::from_u64(23); - let __v_18: G = G::from_u64(189); - let __v_19: G = G::from_u64(15); - let __v_20: G = G::from_u64(61); - let __v_21: G = G::from_u64(210); - let __v_22: G = G::from_u64(186); - let __v_23: G = G::from_u64(122); - let __v_24: G = G::from_u64(82); - let __v_25: G = G::from_u64(37); - let __v_26: G = G::from_u64(51); - let __v_27: G = G::from_u64(194); - let __v_28: G = G::from_u64(205); - let __v_29: G = G::from_u64(158); - let __v_30: G = G::from_u64(29); - let __v_31: G = G::from_u64(11); + let __v_0: G = G::from_u64(230); + let __v_1: G = G::from_u64(235); + let __v_2: G = G::from_u64(163); + let __v_3: G = G::from_u64(200); + let __v_4: G = G::from_u64(180); + let __v_5: G = G::from_u64(209); + let __v_6: G = G::from_u64(159); + let __v_7: G = G::from_u64(106); + let __v_8: G = G::from_u64(16); + let __v_9: G = G::from_u64(118); + let __v_10: G = G::from_u64(179); + let __v_11: G = G::from_u64(159); + let __v_12: G = G::from_u64(168); + let __v_13: G = G::from_u64(154); + let __v_14: G = G::from_u64(236); + let __v_15: G = G::from_u64(97); + let __v_16: G = G::from_u64(220); + let __v_17: G = G::from_u64(203); + let __v_18: G = G::from_u64(185); + let __v_19: G = G::from_u64(96); + let __v_20: G = G::from_u64(248); + let __v_21: G = G::from_u64(61); + let __v_22: G = G::from_u64(154); + let __v_23: G = G::from_u64(98); + let __v_24: G = G::from_u64(230); + let __v_25: G = G::from_u64(172); + let __v_26: G = G::from_u64(243); + let __v_27: G = G::from_u64(90); + let __v_28: G = G::from_u64(105); + 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_247] = [__v_32]; record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25794,38 +25745,38 @@ fn aiur_fn_248( unconstrained: bool, ) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(156); - let __v_1: G = G::from_u64(10); - let __v_2: G = G::from_u64(242); - let __v_3: G = G::from_u64(163); - let __v_4: G = G::from_u64(147); - let __v_5: G = G::from_u64(203); - let __v_6: G = G::from_u64(92); - let __v_7: G = G::from_u64(8); - let __v_8: G = G::from_u64(53); - let __v_9: G = G::from_u64(228); - let __v_10: G = G::from_u64(78); - let __v_11: G = G::from_u64(96); - let __v_12: G = G::from_u64(228); - let __v_13: G = G::from_u64(195); - let __v_14: G = G::from_u64(230); - let __v_15: G = G::from_u64(142); - let __v_16: G = G::from_u64(235); - let __v_17: G = G::from_u64(38); - let __v_18: G = G::from_u64(111); - let __v_19: G = G::from_u64(209); - let __v_20: G = G::from_u64(106); - let __v_21: G = G::from_u64(255); - let __v_22: G = G::from_u64(173); - let __v_23: G = G::from_u64(50); - let __v_24: G = G::from_u64(22); - let __v_25: G = G::from_u64(9); - let __v_26: G = G::from_u64(106); + let __v_0: G = G::from_u64(3); + let __v_1: G = G::from_u64(107); + let __v_2: G = G::from_u64(99); + let __v_3: G = G::from_u64(213); + let __v_4: G = G::from_u64(204); + let __v_5: G = G::from_u64(9); + let __v_6: G = G::from_u64(97); + let __v_7: G = G::from_u64(233); + let __v_8: G = G::from_u64(32); + let __v_9: G = G::from_u64(222); + let __v_10: G = G::from_u64(229); + let __v_11: G = G::from_u64(14); + let __v_12: G = G::from_u64(115); + let __v_13: G = G::from_u64(100); + let __v_14: G = G::from_u64(236); + let __v_15: G = G::from_u64(13); + let __v_16: G = G::from_u64(211); + let __v_17: G = G::from_u64(249); + let __v_18: G = G::from_u64(195); + let __v_19: G = G::from_u64(138); + let __v_20: G = G::from_u64(156); + let __v_21: G = G::from_u64(172); + let __v_22: G = G::from_u64(228); + let __v_23: G = G::from_u64(14); + let __v_24: G = G::from_u64(81); + let __v_25: G = G::from_u64(59); + let __v_26: G = G::from_u64(56); let __v_27: G = G::from_u64(53); - let __v_28: G = G::from_u64(254); - let __v_29: G = G::from_u64(145); - let __v_30: G = G::from_u64(185); - let __v_31: G = G::from_u64(193); + let __v_28: G = G::from_u64(222); + 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 __ret: [G; OUT_248] = [__v_32]; record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25843,38 +25794,38 @@ fn aiur_fn_249( unconstrained: bool, ) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(30); - let __v_1: G = G::from_u64(37); - let __v_2: G = G::from_u64(17); - let __v_3: G = G::from_u64(152); - let __v_4: G = G::from_u64(243); - let __v_5: G = G::from_u64(6); - let __v_6: G = G::from_u64(37); - let __v_7: G = G::from_u64(98); - let __v_8: G = G::from_u64(142); - let __v_9: G = G::from_u64(46); - let __v_10: G = G::from_u64(176); - let __v_11: G = G::from_u64(152); - let __v_12: G = G::from_u64(63); - let __v_13: G = G::from_u64(123); - let __v_14: G = G::from_u64(233); - let __v_15: G = G::from_u64(239); - let __v_16: G = G::from_u64(232); - let __v_17: G = G::from_u64(215); - let __v_18: G = G::from_u64(25); - let __v_19: G = G::from_u64(161); - let __v_20: G = G::from_u64(4); - let __v_21: G = G::from_u64(168); - let __v_22: G = G::from_u64(97); - let __v_23: G = G::from_u64(242); - let __v_24: G = G::from_u64(190); - let __v_25: G = G::from_u64(242); - let __v_26: G = G::from_u64(244); - let __v_27: G = G::from_u64(126); - let __v_28: G = G::from_u64(171); - let __v_29: G = G::from_u64(238); - let __v_30: G = G::from_u64(212); - let __v_31: G = G::from_u64(249); + let __v_0: G = G::from_u64(108); + let __v_1: G = G::from_u64(155); + let __v_2: G = G::from_u64(214); + let __v_3: G = G::from_u64(14); + let __v_4: G = G::from_u64(30); + let __v_5: G = G::from_u64(174); + let __v_6: G = G::from_u64(147); + let __v_7: G = G::from_u64(142); + let __v_8: G = G::from_u64(86); + let __v_9: G = G::from_u64(38); + let __v_10: G = G::from_u64(202); + let __v_11: G = G::from_u64(35); + let __v_12: G = G::from_u64(125); + let __v_13: G = G::from_u64(188); + let __v_14: G = G::from_u64(167); + let __v_15: G = G::from_u64(253); + let __v_16: G = G::from_u64(149); + let __v_17: G = G::from_u64(15); + let __v_18: G = G::from_u64(46); + let __v_19: G = G::from_u64(153); + let __v_20: G = G::from_u64(226); + let __v_21: G = G::from_u64(52); + let __v_22: G = G::from_u64(169); + let __v_23: G = G::from_u64(156); + let __v_24: G = G::from_u64(35); + let __v_25: G = G::from_u64(207); + let __v_26: G = G::from_u64(220); + let __v_27: G = G::from_u64(41); + let __v_28: G = G::from_u64(76); + 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 __ret: [G; OUT_249] = [__v_32]; record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25892,38 +25843,38 @@ fn aiur_fn_250( unconstrained: bool, ) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(226); - let __v_1: G = G::from_u64(216); - let __v_2: G = G::from_u64(41); - let __v_3: G = G::from_u64(46); - let __v_4: G = G::from_u64(26); - let __v_5: G = G::from_u64(223); - let __v_6: G = G::from_u64(84); - let __v_7: G = G::from_u64(176); - let __v_8: G = G::from_u64(211); - let __v_9: G = G::from_u64(147); - let __v_10: G = G::from_u64(0); - let __v_11: G = G::from_u64(132); - let __v_12: G = G::from_u64(119); - let __v_13: G = G::from_u64(24); - let __v_14: G = G::from_u64(220); - let __v_15: G = G::from_u64(137); - let __v_16: G = G::from_u64(166); - let __v_17: G = G::from_u64(51); - let __v_18: G = G::from_u64(50); - let __v_19: G = G::from_u64(232); - let __v_20: G = G::from_u64(243); - let __v_21: G = G::from_u64(27); - let __v_22: G = G::from_u64(65); - let __v_23: G = G::from_u64(201); - let __v_24: G = G::from_u64(232); - let __v_25: G = G::from_u64(15); - let __v_26: G = G::from_u64(140); - let __v_27: G = G::from_u64(154); - let __v_28: G = G::from_u64(32); - let __v_29: G = G::from_u64(23); - let __v_30: G = G::from_u64(39); - let __v_31: G = G::from_u64(141); + 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_250] = [__v_32]; record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25941,38 +25892,38 @@ fn aiur_fn_251( unconstrained: bool, ) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(134); - let __v_1: G = G::from_u64(41); - let __v_2: G = G::from_u64(81); - let __v_3: G = G::from_u64(150); - let __v_4: G = G::from_u64(50); - let __v_5: G = G::from_u64(225); - let __v_6: G = G::from_u64(140); - let __v_7: G = G::from_u64(73); - let __v_8: G = G::from_u64(9); - let __v_9: G = G::from_u64(121); - let __v_10: G = G::from_u64(54); - let __v_11: G = G::from_u64(252); - let __v_12: G = G::from_u64(34); - let __v_13: G = G::from_u64(12); - let __v_14: G = G::from_u64(158); - let __v_15: G = G::from_u64(3); - let __v_16: G = G::from_u64(214); - let __v_17: G = G::from_u64(38); - let __v_18: G = G::from_u64(63); - let __v_19: G = G::from_u64(221); - let __v_20: G = G::from_u64(235); - let __v_21: G = G::from_u64(164); - let __v_22: G = G::from_u64(70); - let __v_23: G = G::from_u64(42); - let __v_24: G = G::from_u64(245); - let __v_25: G = G::from_u64(183); - let __v_26: G = G::from_u64(23); - let __v_27: G = G::from_u64(221); - let __v_28: G = G::from_u64(17); - let __v_29: G = G::from_u64(228); - let __v_30: G = G::from_u64(190); - let __v_31: G = G::from_u64(244); + 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)); __ptr } }; let __ret: [G; OUT_251] = [__v_32]; record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25990,38 +25941,38 @@ fn aiur_fn_252( unconstrained: bool, ) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(66); - let __v_1: G = G::from_u64(149); - let __v_2: G = G::from_u64(192); - let __v_3: G = G::from_u64(113); - let __v_4: G = G::from_u64(169); - let __v_5: G = G::from_u64(72); - let __v_6: G = G::from_u64(90); - let __v_7: G = G::from_u64(242); - let __v_8: G = G::from_u64(217); - let __v_9: G = G::from_u64(152); - let __v_10: G = G::from_u64(227); - let __v_11: G = G::from_u64(148); - let __v_12: G = G::from_u64(123); - let __v_13: G = G::from_u64(229); - let __v_14: G = G::from_u64(152); - let __v_15: G = G::from_u64(128); - let __v_16: G = G::from_u64(119); - let __v_17: G = G::from_u64(83); - let __v_18: G = G::from_u64(31); - let __v_19: G = G::from_u64(2); - let __v_20: G = G::from_u64(191); - let __v_21: G = G::from_u64(9); - let __v_22: G = G::from_u64(27); - let __v_23: G = G::from_u64(135); - let __v_24: G = G::from_u64(13); - let __v_25: G = G::from_u64(83); - let __v_26: G = G::from_u64(206); - let __v_27: G = G::from_u64(88); - let __v_28: G = G::from_u64(157); - let __v_29: G = G::from_u64(78); - let __v_30: G = G::from_u64(245); - let __v_31: G = G::from_u64(177); + 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)); __ptr } }; let __ret: [G; OUT_252] = [__v_32]; record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26039,38 +25990,38 @@ fn aiur_fn_253( unconstrained: bool, ) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(25); - let __v_1: G = G::from_u64(224); - let __v_2: G = G::from_u64(27); - let __v_3: G = G::from_u64(201); - let __v_4: G = G::from_u64(163); - let __v_5: G = G::from_u64(38); - let __v_6: G = G::from_u64(75); - let __v_7: G = G::from_u64(155); - let __v_8: G = G::from_u64(139); - let __v_9: G = G::from_u64(148); - let __v_10: G = G::from_u64(12); - let __v_11: G = G::from_u64(241); - let __v_12: G = G::from_u64(114); - let __v_13: G = G::from_u64(162); - let __v_14: G = G::from_u64(9); - let __v_15: G = G::from_u64(187); - let __v_16: G = G::from_u64(119); - let __v_17: G = G::from_u64(74); - let __v_18: G = G::from_u64(211); - let __v_19: G = G::from_u64(111); - let __v_20: G = G::from_u64(100); - let __v_21: G = G::from_u64(16); - let __v_22: G = G::from_u64(250); - let __v_23: G = G::from_u64(116); - let __v_24: G = G::from_u64(47); - let __v_25: G = G::from_u64(0); - let __v_26: G = G::from_u64(72); - let __v_27: G = G::from_u64(4); - let __v_28: G = G::from_u64(104); - let __v_29: G = G::from_u64(8); - let __v_30: G = G::from_u64(192); - let __v_31: G = G::from_u64(182); + 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_253] = [__v_32]; record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26088,38 +26039,38 @@ fn aiur_fn_254( unconstrained: bool, ) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(126); - let __v_1: G = G::from_u64(4); - let __v_2: G = G::from_u64(142); - let __v_3: G = G::from_u64(243); - let __v_4: G = G::from_u64(3); - let __v_5: G = G::from_u64(236); - let __v_6: G = G::from_u64(220); - let __v_7: G = G::from_u64(131); - let __v_8: G = G::from_u64(100); - let __v_9: G = G::from_u64(103); - let __v_10: G = G::from_u64(205); - let __v_11: G = G::from_u64(212); - let __v_12: G = G::from_u64(216); - let __v_13: G = G::from_u64(146); - let __v_14: G = G::from_u64(247); - let __v_15: G = G::from_u64(254); - let __v_16: G = G::from_u64(38); - let __v_17: G = G::from_u64(251); - let __v_18: G = G::from_u64(189); - let __v_19: G = G::from_u64(123); - let __v_20: G = G::from_u64(98); - let __v_21: G = G::from_u64(174); - let __v_22: G = G::from_u64(29); - let __v_23: G = G::from_u64(23); - let __v_24: G = G::from_u64(70); - let __v_25: G = G::from_u64(84); - let __v_26: G = G::from_u64(63); - let __v_27: G = G::from_u64(78); - let __v_28: G = G::from_u64(48); - let __v_29: G = G::from_u64(152); - let __v_30: G = G::from_u64(198); - let __v_31: G = G::from_u64(225); + 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)); __ptr } }; let __ret: [G; OUT_254] = [__v_32]; record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26137,38 +26088,38 @@ fn aiur_fn_255( unconstrained: bool, ) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(108); - let __v_1: G = G::from_u64(194); - let __v_2: G = G::from_u64(214); - let __v_3: G = G::from_u64(61); - let __v_4: G = G::from_u64(161); - let __v_5: G = G::from_u64(253); - let __v_6: G = G::from_u64(7); - let __v_7: G = G::from_u64(226); - let __v_8: G = G::from_u64(83); - let __v_9: G = G::from_u64(63); - let __v_10: G = G::from_u64(203); - let __v_11: G = G::from_u64(8); - let __v_12: G = G::from_u64(203); - let __v_13: G = G::from_u64(179); - let __v_14: G = G::from_u64(140); - let __v_15: G = G::from_u64(45); - let __v_16: G = G::from_u64(103); - let __v_17: G = G::from_u64(247); - let __v_18: G = G::from_u64(81); - let __v_19: G = G::from_u64(42); - let __v_20: G = G::from_u64(126); - let __v_21: G = G::from_u64(253); - let __v_22: G = G::from_u64(21); - let __v_23: G = G::from_u64(35); - let __v_24: G = G::from_u64(106); - let __v_25: G = G::from_u64(75); - let __v_26: G = G::from_u64(14); - let __v_27: G = G::from_u64(87); - let __v_28: G = G::from_u64(187); - let __v_29: G = G::from_u64(31); - let __v_30: G = G::from_u64(205); - let __v_31: G = G::from_u64(83); + 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)); __ptr } }; let __ret: [G; OUT_255] = [__v_32]; record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26186,38 +26137,38 @@ fn aiur_fn_256( unconstrained: bool, ) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(70); - let __v_1: G = G::from_u64(181); - let __v_2: G = G::from_u64(235); - let __v_3: G = G::from_u64(103); - let __v_4: G = G::from_u64(104); - let __v_5: G = G::from_u64(193); - let __v_6: G = G::from_u64(244); - let __v_7: G = G::from_u64(149); - let __v_8: G = G::from_u64(135); - let __v_9: G = G::from_u64(214); - let __v_10: G = G::from_u64(83); - let __v_11: G = G::from_u64(193); - let __v_12: G = G::from_u64(46); - let __v_13: G = G::from_u64(55); - let __v_14: G = G::from_u64(51); - let __v_15: G = G::from_u64(137); - let __v_16: G = G::from_u64(18); - let __v_17: G = G::from_u64(21); - let __v_18: G = G::from_u64(51); - let __v_19: G = G::from_u64(134); - let __v_20: G = G::from_u64(131); - let __v_21: G = G::from_u64(47); - let __v_22: G = G::from_u64(15); - let __v_23: G = G::from_u64(208); - let __v_24: G = G::from_u64(228); - let __v_25: G = G::from_u64(114); - let __v_26: G = G::from_u64(72); - let __v_27: G = G::from_u64(78); - let __v_28: G = G::from_u64(38); - let __v_29: G = G::from_u64(50); - let __v_30: G = G::from_u64(38); - let __v_31: G = G::from_u64(50); + let __v_0: G = G::from_u64(9); + let __v_1: G = G::from_u64(188); + let __v_2: G = G::from_u64(37); + let __v_3: G = G::from_u64(49); + let __v_4: G = G::from_u64(71); + let __v_5: G = G::from_u64(195); + let __v_6: G = G::from_u64(108); + let __v_7: G = G::from_u64(226); + let __v_8: G = G::from_u64(44); + let __v_9: G = G::from_u64(142); + let __v_10: G = G::from_u64(12); + let __v_11: G = G::from_u64(205); + let __v_12: G = G::from_u64(67); + let __v_13: G = G::from_u64(199); + let __v_14: G = G::from_u64(155); + let __v_15: G = G::from_u64(44); + let __v_16: G = G::from_u64(218); + let __v_17: G = G::from_u64(226); + let __v_18: G = G::from_u64(32); + let __v_19: G = G::from_u64(110); + let __v_20: G = G::from_u64(13); + let __v_21: G = G::from_u64(221); + let __v_22: G = G::from_u64(22); + let __v_23: G = G::from_u64(143); + let __v_24: G = G::from_u64(202); + let __v_25: G = G::from_u64(54); + let __v_26: G = G::from_u64(9); + let __v_27: G = G::from_u64(178); + let __v_28: G = G::from_u64(165); + 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_256] = [__v_32]; record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26235,38 +26186,38 @@ fn aiur_fn_257( unconstrained: bool, ) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(37); - let __v_1: G = G::from_u64(187); - let __v_2: G = G::from_u64(205); - let __v_3: G = G::from_u64(117); - let __v_4: G = G::from_u64(107); - let __v_5: G = G::from_u64(82); - let __v_6: G = G::from_u64(235); - let __v_7: G = G::from_u64(120); - let __v_8: G = G::from_u64(188); - let __v_9: G = G::from_u64(225); - let __v_10: G = G::from_u64(112); - let __v_11: G = G::from_u64(65); - let __v_12: G = G::from_u64(13); - let __v_13: G = G::from_u64(239); - let __v_14: G = G::from_u64(164); - let __v_15: G = G::from_u64(193); - let __v_16: G = G::from_u64(91); - let __v_17: G = G::from_u64(35); - let __v_18: G = G::from_u64(141); - let __v_19: G = G::from_u64(237); - let __v_20: G = G::from_u64(239); - let __v_21: G = G::from_u64(95); - let __v_22: G = G::from_u64(123); - let __v_23: G = G::from_u64(137); - let __v_24: G = G::from_u64(105); - let __v_25: G = G::from_u64(22); - let __v_26: G = G::from_u64(33); - let __v_27: G = G::from_u64(220); - let __v_28: G = G::from_u64(190); - let __v_29: G = G::from_u64(145); - let __v_30: G = G::from_u64(151); - let __v_31: G = G::from_u64(128); + let __v_0: G = G::from_u64(38); + let __v_1: G = G::from_u64(124); + let __v_2: G = G::from_u64(10); + let __v_3: G = G::from_u64(156); + let __v_4: G = G::from_u64(146); + let __v_5: G = G::from_u64(231); + let __v_6: G = G::from_u64(86); + let __v_7: G = G::from_u64(56); + let __v_8: G = G::from_u64(252); + let __v_9: G = G::from_u64(115); + let __v_10: G = G::from_u64(237); + let __v_11: G = G::from_u64(82); + let __v_12: G = G::from_u64(169); + let __v_13: G = G::from_u64(249); + let __v_14: G = G::from_u64(200); + let __v_15: G = G::from_u64(22); + let __v_16: G = G::from_u64(71); + let __v_17: G = G::from_u64(238); + let __v_18: G = G::from_u64(236); + let __v_19: G = G::from_u64(238); + let __v_20: G = G::from_u64(255); + let __v_21: G = G::from_u64(33); + let __v_22: G = G::from_u64(68); + let __v_23: G = G::from_u64(193); + let __v_24: G = G::from_u64(249); + let __v_25: G = G::from_u64(126); + let __v_26: G = G::from_u64(101); + let __v_27: G = G::from_u64(226); + let __v_28: G = G::from_u64(175); + 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_257] = [__v_32]; record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26284,38 +26235,38 @@ fn aiur_fn_258( unconstrained: bool, ) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(39); - let __v_1: G = G::from_u64(42); - let __v_2: G = G::from_u64(169); - let __v_3: G = G::from_u64(225); - let __v_4: G = G::from_u64(108); - let __v_5: G = G::from_u64(3); - let __v_6: G = G::from_u64(233); - let __v_7: G = G::from_u64(173); - let __v_8: G = G::from_u64(115); - let __v_9: G = G::from_u64(55); - let __v_10: G = G::from_u64(231); - let __v_11: G = G::from_u64(6); - let __v_12: G = G::from_u64(215); - let __v_13: G = G::from_u64(62); - let __v_14: G = G::from_u64(253); - let __v_15: G = G::from_u64(20); - let __v_16: G = G::from_u64(204); - let __v_17: G = G::from_u64(241); - let __v_18: G = G::from_u64(218); - let __v_19: G = G::from_u64(16); - let __v_20: G = G::from_u64(226); - let __v_21: G = G::from_u64(248); - let __v_22: G = G::from_u64(54); - let __v_23: G = G::from_u64(125); - let __v_24: G = G::from_u64(211); - let __v_25: G = G::from_u64(67); - let __v_26: G = G::from_u64(116); - let __v_27: G = G::from_u64(182); - let __v_28: G = G::from_u64(14); - let __v_29: G = G::from_u64(21); - let __v_30: G = G::from_u64(86); - let __v_31: G = G::from_u64(250); + let __v_0: G = G::from_u64(116); + let __v_1: G = G::from_u64(89); + let __v_2: G = G::from_u64(54); + let __v_3: G = G::from_u64(252); + let __v_4: G = G::from_u64(185); + let __v_5: G = G::from_u64(216); + let __v_6: G = G::from_u64(108); + let __v_7: G = G::from_u64(68); + let __v_8: G = G::from_u64(87); + let __v_9: G = G::from_u64(240); + let __v_10: G = G::from_u64(253); + let __v_11: G = G::from_u64(30); + let __v_12: G = G::from_u64(83); + let __v_13: G = G::from_u64(126); + let __v_14: G = G::from_u64(103); + let __v_15: G = G::from_u64(7); + let __v_16: G = G::from_u64(127); + let __v_17: G = G::from_u64(70); + let __v_18: G = G::from_u64(247); + let __v_19: G = G::from_u64(132); + let __v_20: G = G::from_u64(17); + let __v_21: G = G::from_u64(8); + let __v_22: G = G::from_u64(65); + let __v_23: G = G::from_u64(157); + let __v_24: G = G::from_u64(172); + let __v_25: G = G::from_u64(121); + let __v_26: G = G::from_u64(132); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(139); + 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_258] = [__v_32]; record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26333,38 +26284,38 @@ fn aiur_fn_259( unconstrained: bool, ) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(122); - let __v_1: G = G::from_u64(24); - let __v_2: G = G::from_u64(202); - let __v_3: G = G::from_u64(132); - let __v_4: G = G::from_u64(161); - let __v_5: G = G::from_u64(19); - let __v_6: G = G::from_u64(176); - let __v_7: G = G::from_u64(194); - let __v_8: G = G::from_u64(173); - let __v_9: G = G::from_u64(12); - let __v_10: G = G::from_u64(192); - let __v_11: G = G::from_u64(232); - let __v_12: G = G::from_u64(37); - let __v_13: G = G::from_u64(165); - let __v_14: G = G::from_u64(93); - let __v_15: G = G::from_u64(118); - let __v_16: G = G::from_u64(126); - let __v_17: G = G::from_u64(119); - let __v_18: G = G::from_u64(168); - let __v_19: G = G::from_u64(158); - let __v_20: G = G::from_u64(141); - let __v_21: G = G::from_u64(14); - let __v_22: G = G::from_u64(29); - let __v_23: G = G::from_u64(130); - let __v_24: G = G::from_u64(235); - let __v_25: G = G::from_u64(145); - let __v_26: G = G::from_u64(4); - let __v_27: G = G::from_u64(133); - let __v_28: G = G::from_u64(159); - let __v_29: G = G::from_u64(83); - let __v_30: G = G::from_u64(208); - let __v_31: G = G::from_u64(149); + let __v_0: G = G::from_u64(171); + let __v_1: G = G::from_u64(55); + let __v_2: G = G::from_u64(118); + let __v_3: G = G::from_u64(152); + let __v_4: G = G::from_u64(87); + let __v_5: G = G::from_u64(67); + let __v_6: G = G::from_u64(175); + let __v_7: G = G::from_u64(19); + let __v_8: G = G::from_u64(169); + let __v_9: G = G::from_u64(203); + let __v_10: G = G::from_u64(26); + let __v_11: G = G::from_u64(125); + let __v_12: G = G::from_u64(47); + let __v_13: G = G::from_u64(132); + let __v_14: G = G::from_u64(150); + let __v_15: G = G::from_u64(153); + let __v_16: G = G::from_u64(120); + let __v_17: G = G::from_u64(146); + let __v_18: G = G::from_u64(225); + let __v_19: G = G::from_u64(121); + let __v_20: G = G::from_u64(131); + let __v_21: G = G::from_u64(209); + let __v_22: G = G::from_u64(75); + let __v_23: G = G::from_u64(229); + let __v_24: G = G::from_u64(39); + let __v_25: G = G::from_u64(10); + let __v_26: G = G::from_u64(113); + let __v_27: G = G::from_u64(101); + let __v_28: G = G::from_u64(112); + 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_259] = [__v_32]; record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26382,38 +26333,38 @@ fn aiur_fn_260( unconstrained: bool, ) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(58); - let __v_1: G = G::from_u64(226); - let __v_2: G = G::from_u64(199); - let __v_3: G = G::from_u64(29); - let __v_4: G = G::from_u64(162); - let __v_5: G = G::from_u64(191); - let __v_6: G = G::from_u64(52); - let __v_7: G = G::from_u64(23); - let __v_8: G = G::from_u64(154); - let __v_9: G = G::from_u64(90); - let __v_10: G = G::from_u64(136); - let __v_11: G = G::from_u64(8); - let __v_12: G = G::from_u64(133); - let __v_13: G = G::from_u64(124); - let __v_14: G = G::from_u64(52); - let __v_15: G = G::from_u64(163); - let __v_16: G = G::from_u64(183); - let __v_17: G = G::from_u64(102); - let __v_18: G = G::from_u64(47); - let __v_19: G = G::from_u64(245); - let __v_20: G = G::from_u64(101); - let __v_21: G = G::from_u64(77); - let __v_22: G = G::from_u64(140); - let __v_23: G = G::from_u64(36); - let __v_24: G = G::from_u64(124); - let __v_25: G = G::from_u64(67); - let __v_26: G = G::from_u64(232); - let __v_27: G = G::from_u64(90); - let __v_28: G = G::from_u64(124); - let __v_29: G = G::from_u64(222); - let __v_30: G = G::from_u64(73); - let __v_31: G = G::from_u64(63); + let __v_0: G = G::from_u64(15); + let __v_1: G = G::from_u64(158); + let __v_2: G = G::from_u64(232); + let __v_3: G = G::from_u64(217); + let __v_4: G = G::from_u64(3); + let __v_5: G = G::from_u64(61); + let __v_6: G = G::from_u64(143); + let __v_7: G = G::from_u64(123); + let __v_8: G = G::from_u64(133); + let __v_9: G = G::from_u64(47); + let __v_10: G = G::from_u64(91); + let __v_11: G = G::from_u64(113); + let __v_12: G = G::from_u64(82); + let __v_13: G = G::from_u64(253); + let __v_14: G = G::from_u64(18); + let __v_15: G = G::from_u64(79); + let __v_16: G = G::from_u64(125); + let __v_17: G = G::from_u64(65); + let __v_18: G = G::from_u64(25); + let __v_19: G = G::from_u64(48); + let __v_20: G = G::from_u64(201); + let __v_21: G = G::from_u64(146); + let __v_22: G = G::from_u64(224); + let __v_23: G = G::from_u64(244); + let __v_24: G = G::from_u64(87); + let __v_25: G = G::from_u64(248); + let __v_26: G = G::from_u64(16); + let __v_27: G = G::from_u64(75); + let __v_28: G = G::from_u64(96); + 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_260] = [__v_32]; record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26431,38 +26382,38 @@ fn aiur_fn_261( unconstrained: bool, ) -> Result<[G; OUT_261], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(16); - let __v_1: G = G::from_u64(172); - let __v_2: G = G::from_u64(95); - let __v_3: G = G::from_u64(72); - let __v_4: G = G::from_u64(121); - let __v_5: G = G::from_u64(139); - let __v_6: G = G::from_u64(63); - let __v_7: G = G::from_u64(240); - let __v_8: G = G::from_u64(27); - let __v_9: G = G::from_u64(15); - let __v_10: G = G::from_u64(116); - let __v_11: G = G::from_u64(192); - let __v_12: G = G::from_u64(181); - let __v_13: G = G::from_u64(68); - let __v_14: G = G::from_u64(210); - let __v_15: G = G::from_u64(39); - let __v_16: G = G::from_u64(150); - let __v_17: G = G::from_u64(201); - let __v_18: G = G::from_u64(119); - let __v_19: G = G::from_u64(95); - let __v_20: G = G::from_u64(109); - let __v_21: G = G::from_u64(67); - let __v_22: G = G::from_u64(211); - let __v_23: G = G::from_u64(40); - let __v_24: G = G::from_u64(49); - let __v_25: G = G::from_u64(107); - let __v_26: G = G::from_u64(187); - let __v_27: G = G::from_u64(58); - let __v_28: G = G::from_u64(161); - let __v_29: G = G::from_u64(99); - let __v_30: G = G::from_u64(137); - let __v_31: G = G::from_u64(153); + let __v_0: G = G::from_u64(4); + let __v_1: G = G::from_u64(113); + let __v_2: G = G::from_u64(228); + let __v_3: G = G::from_u64(113); + let __v_4: G = G::from_u64(88); + let __v_5: G = G::from_u64(178); + let __v_6: G = G::from_u64(174); + let __v_7: G = G::from_u64(24); + let __v_8: G = G::from_u64(211); + let __v_9: G = G::from_u64(192); + let __v_10: G = G::from_u64(141); + let __v_11: G = G::from_u64(213); + let __v_12: G = G::from_u64(199); + let __v_13: G = G::from_u64(122); + let __v_14: G = G::from_u64(174); + let __v_15: G = G::from_u64(35); + let __v_16: G = G::from_u64(230); + let __v_17: G = G::from_u64(45); + let __v_18: G = G::from_u64(123); + let __v_19: G = G::from_u64(188); + let __v_20: G = G::from_u64(30); + let __v_21: G = G::from_u64(97); + let __v_22: G = G::from_u64(17); + let __v_23: G = G::from_u64(107); + let __v_24: G = G::from_u64(194); + let __v_25: G = G::from_u64(129); + let __v_26: G = G::from_u64(59); + let __v_27: G = G::from_u64(19); + let __v_28: G = G::from_u64(6); + 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 __ret: [G; OUT_261] = [__v_32]; record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26480,38 +26431,38 @@ fn aiur_fn_262( unconstrained: bool, ) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(186); - let __v_1: G = G::from_u64(179); - let __v_2: G = G::from_u64(122); - let __v_3: G = G::from_u64(139); - let __v_4: G = G::from_u64(217); - let __v_5: G = G::from_u64(134); - let __v_6: G = G::from_u64(13); - let __v_7: G = G::from_u64(59); - let __v_8: G = G::from_u64(254); - let __v_9: G = G::from_u64(49); - let __v_10: G = G::from_u64(241); - let __v_11: G = G::from_u64(161); - let __v_12: G = G::from_u64(117); - let __v_13: G = G::from_u64(47); - let __v_14: G = G::from_u64(231); - let __v_15: G = G::from_u64(0); - let __v_16: G = G::from_u64(138); - let __v_17: G = G::from_u64(34); - let __v_18: G = G::from_u64(76); - let __v_19: G = G::from_u64(106); - let __v_20: G = G::from_u64(216); - let __v_21: G = G::from_u64(175); - let __v_22: G = G::from_u64(98); - let __v_23: G = G::from_u64(60); - let __v_24: G = G::from_u64(127); - let __v_25: G = G::from_u64(184); - let __v_26: G = G::from_u64(189); - let __v_27: G = G::from_u64(25); - let __v_28: G = G::from_u64(43); - let __v_29: G = G::from_u64(229); - let __v_30: G = G::from_u64(192); - let __v_31: G = G::from_u64(126); + 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_262] = [__v_32]; record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26529,38 +26480,38 @@ fn aiur_fn_263( unconstrained: bool, ) -> Result<[G; OUT_263], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(152); - let __v_1: G = G::from_u64(27); - let __v_2: G = G::from_u64(0); - let __v_3: G = G::from_u64(183); - let __v_4: G = G::from_u64(196); - let __v_5: G = G::from_u64(88); - let __v_6: G = G::from_u64(153); - let __v_7: G = G::from_u64(247); - let __v_8: G = G::from_u64(38); - let __v_9: G = G::from_u64(195); - let __v_10: G = G::from_u64(222); - let __v_11: G = G::from_u64(53); - let __v_12: G = G::from_u64(50); - let __v_13: G = G::from_u64(128); - let __v_14: G = G::from_u64(116); - let __v_15: G = G::from_u64(203); - let __v_16: G = G::from_u64(63); - let __v_17: G = G::from_u64(114); - let __v_18: G = G::from_u64(160); - let __v_19: G = G::from_u64(146); - let __v_20: G = G::from_u64(37); - let __v_21: G = G::from_u64(116); - let __v_22: G = G::from_u64(61); - let __v_23: G = G::from_u64(168); - let __v_24: G = G::from_u64(31); - let __v_25: G = G::from_u64(80); - let __v_26: G = G::from_u64(49); - let __v_27: G = G::from_u64(255); - let __v_28: G = G::from_u64(110); - let __v_29: G = G::from_u64(100); - let __v_30: G = G::from_u64(123); - let __v_31: G = G::from_u64(169); + 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)); __ptr } }; let __ret: [G; OUT_263] = [__v_32]; record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26578,38 +26529,38 @@ fn aiur_fn_264( unconstrained: bool, ) -> Result<[G; OUT_264], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(165); - let __v_1: G = G::from_u64(123); - let __v_2: G = G::from_u64(129); - let __v_3: G = G::from_u64(128); - let __v_4: G = G::from_u64(40); - let __v_5: G = G::from_u64(135); - let __v_6: G = G::from_u64(1); - let __v_7: G = G::from_u64(206); - let __v_8: G = G::from_u64(191); - let __v_9: G = G::from_u64(177); - let __v_10: G = G::from_u64(214); - let __v_11: G = G::from_u64(221); - let __v_12: G = G::from_u64(41); - let __v_13: G = G::from_u64(241); - let __v_14: G = G::from_u64(96); - let __v_15: G = G::from_u64(204); - let __v_16: G = G::from_u64(74); - let __v_17: G = G::from_u64(204); - let __v_18: G = G::from_u64(60); - let __v_19: G = G::from_u64(106); - let __v_20: G = G::from_u64(186); - let __v_21: G = G::from_u64(152); - let __v_22: G = G::from_u64(52); - let __v_23: G = G::from_u64(228); - let __v_24: G = G::from_u64(107); - let __v_25: G = G::from_u64(101); - let __v_26: G = G::from_u64(241); - let __v_27: G = G::from_u64(197); - let __v_28: G = G::from_u64(170); - let __v_29: G = G::from_u64(114); - let __v_30: G = G::from_u64(23); - let __v_31: G = G::from_u64(226); + 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)); __ptr } }; let __ret: [G; OUT_264] = [__v_32]; record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26627,38 +26578,38 @@ fn aiur_fn_265( unconstrained: bool, ) -> Result<[G; OUT_265], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(110); - let __v_1: G = G::from_u64(155); - let __v_2: G = G::from_u64(60); - let __v_3: G = G::from_u64(28); - let __v_4: G = G::from_u64(165); - let __v_5: G = G::from_u64(217); - let __v_6: G = G::from_u64(240); - let __v_7: G = G::from_u64(155); - let __v_8: G = G::from_u64(144); - let __v_9: G = G::from_u64(35); - let __v_10: G = G::from_u64(33); - let __v_11: G = G::from_u64(177); - let __v_12: G = G::from_u64(85); - let __v_13: G = G::from_u64(237); - let __v_14: G = G::from_u64(244); - let __v_15: G = G::from_u64(82); - let __v_16: G = G::from_u64(76); - let __v_17: G = G::from_u64(62); - let __v_18: G = G::from_u64(50); - let __v_19: G = G::from_u64(222); - let __v_20: G = G::from_u64(29); - let __v_21: G = G::from_u64(105); - let __v_22: G = G::from_u64(13); - let __v_23: G = G::from_u64(185); - let __v_24: G = G::from_u64(23); - let __v_25: G = G::from_u64(191); - let __v_26: G = G::from_u64(186); - let __v_27: G = G::from_u64(170); - let __v_28: G = G::from_u64(172); - let __v_29: G = G::from_u64(63); - let __v_30: G = G::from_u64(143); - let __v_31: G = G::from_u64(130); + 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)); __ptr } }; let __ret: [G; OUT_265] = [__v_32]; record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26676,38 +26627,38 @@ fn aiur_fn_266( unconstrained: bool, ) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(110); - let __v_1: G = G::from_u64(69); - let __v_2: G = G::from_u64(58); - let __v_3: G = G::from_u64(124); - let __v_4: G = G::from_u64(237); - let __v_5: G = G::from_u64(175); - let __v_6: G = G::from_u64(226); - let __v_7: G = G::from_u64(237); - let __v_8: G = G::from_u64(187); - let __v_9: G = G::from_u64(193); - let __v_10: G = G::from_u64(240); - let __v_11: G = G::from_u64(80); - let __v_12: G = G::from_u64(52); - let __v_13: G = G::from_u64(66); - let __v_14: G = G::from_u64(190); - let __v_15: G = G::from_u64(73); - let __v_16: G = G::from_u64(158); - let __v_17: G = G::from_u64(76); - let __v_18: G = G::from_u64(191); - let __v_19: G = G::from_u64(24); - let __v_20: G = G::from_u64(166); - let __v_21: G = G::from_u64(192); - let __v_22: G = G::from_u64(13); - let __v_23: G = G::from_u64(201); - let __v_24: G = G::from_u64(159); - let __v_25: G = G::from_u64(57); - let __v_26: G = G::from_u64(3); - let __v_27: G = G::from_u64(238); - let __v_28: G = G::from_u64(127); - let __v_29: G = G::from_u64(5); - let __v_30: G = G::from_u64(219); - let __v_31: G = G::from_u64(175); + let __v_0: G = G::from_u64(28); + let __v_1: G = G::from_u64(23); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(152); + let __v_4: G = G::from_u64(226); + let __v_5: G = G::from_u64(49); + let __v_6: G = G::from_u64(67); + let __v_7: G = G::from_u64(253); + let __v_8: G = G::from_u64(143); + let __v_9: G = G::from_u64(214); + let __v_10: G = G::from_u64(23); + let __v_11: G = G::from_u64(44); + let __v_12: G = G::from_u64(239); + let __v_13: G = G::from_u64(210); + let __v_14: G = G::from_u64(236); + let __v_15: G = G::from_u64(238); + let __v_16: G = G::from_u64(48); + let __v_17: G = G::from_u64(80); + let __v_18: G = G::from_u64(114); + let __v_19: G = G::from_u64(210); + let __v_20: G = G::from_u64(153); + let __v_21: G = G::from_u64(17); + let __v_22: G = G::from_u64(19); + let __v_23: G = G::from_u64(207); + let __v_24: G = G::from_u64(196); + let __v_25: G = G::from_u64(213); + let __v_26: G = G::from_u64(40); + let __v_27: G = G::from_u64(64); + let __v_28: G = G::from_u64(165); + 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 __ret: [G; OUT_266] = [__v_32]; record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26725,38 +26676,38 @@ fn aiur_fn_267( unconstrained: bool, ) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(84); - let __v_1: G = G::from_u64(25); - let __v_2: G = G::from_u64(24); - let __v_3: G = G::from_u64(127); - let __v_4: G = G::from_u64(191); - let __v_5: G = G::from_u64(103); - let __v_6: G = G::from_u64(239); - let __v_7: G = G::from_u64(28); - let __v_8: G = G::from_u64(79); - let __v_9: G = G::from_u64(249); - let __v_10: G = G::from_u64(171); - let __v_11: G = G::from_u64(11); - let __v_12: G = G::from_u64(225); - let __v_13: G = G::from_u64(176); - let __v_14: G = G::from_u64(29); - let __v_15: G = G::from_u64(70); - let __v_16: G = G::from_u64(49); - let __v_17: G = G::from_u64(162); - let __v_18: G = G::from_u64(112); - let __v_19: G = G::from_u64(100); - let __v_20: G = G::from_u64(127); - let __v_21: G = G::from_u64(254); - let __v_22: G = G::from_u64(67); - let __v_23: G = G::from_u64(75); - let __v_24: G = G::from_u64(247); - let __v_25: G = G::from_u64(225); - let __v_26: G = G::from_u64(247); - let __v_27: G = G::from_u64(136); - let __v_28: G = G::from_u64(179); - let __v_29: G = G::from_u64(200); - let __v_30: G = G::from_u64(29); - let __v_31: G = G::from_u64(212); + let __v_0: G = G::from_u64(22); + let __v_1: G = G::from_u64(133); + let __v_2: G = G::from_u64(48); + let __v_3: G = G::from_u64(118); + let __v_4: G = G::from_u64(176); + let __v_5: G = G::from_u64(217); + let __v_6: G = G::from_u64(109); + let __v_7: G = G::from_u64(53); + let __v_8: G = G::from_u64(109); + let __v_9: G = G::from_u64(133); + let __v_10: G = G::from_u64(72); + let __v_11: G = G::from_u64(92); + let __v_12: G = G::from_u64(86); + let __v_13: G = G::from_u64(243); + let __v_14: G = G::from_u64(57); + let __v_15: G = G::from_u64(128); + let __v_16: G = G::from_u64(20); + let __v_17: G = G::from_u64(182); + let __v_18: G = G::from_u64(160); + let __v_19: G = G::from_u64(242); + let __v_20: G = G::from_u64(238); + let __v_21: G = G::from_u64(114); + let __v_22: G = G::from_u64(171); + let __v_23: G = G::from_u64(22); + let __v_24: G = G::from_u64(40); + let __v_25: G = G::from_u64(74); + let __v_26: G = G::from_u64(56); + let __v_27: G = G::from_u64(29); + let __v_28: G = G::from_u64(156); + 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 __ret: [G; OUT_267] = [__v_32]; record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26774,38 +26725,38 @@ fn aiur_fn_268( unconstrained: bool, ) -> Result<[G; OUT_268], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(212); - let __v_1: G = G::from_u64(131); - let __v_2: G = G::from_u64(150); - let __v_3: G = G::from_u64(100); - let __v_4: G = G::from_u64(56); - let __v_5: G = G::from_u64(173); - let __v_6: G = G::from_u64(71); - let __v_7: G = G::from_u64(206); - let __v_8: G = G::from_u64(65); - let __v_9: G = G::from_u64(85); - let __v_10: G = G::from_u64(179); - let __v_11: G = G::from_u64(72); - let __v_12: G = G::from_u64(88); - let __v_13: G = G::from_u64(25); - let __v_14: G = G::from_u64(163); - let __v_15: G = G::from_u64(119); - let __v_16: G = G::from_u64(226); - let __v_17: G = G::from_u64(38); - let __v_18: G = G::from_u64(5); - let __v_19: G = G::from_u64(181); - let __v_20: G = G::from_u64(154); - let __v_21: G = G::from_u64(26); - let __v_22: G = G::from_u64(175); - let __v_23: G = G::from_u64(208); - let __v_24: G = G::from_u64(182); - let __v_25: G = G::from_u64(129); - let __v_26: G = G::from_u64(203); - let __v_27: G = G::from_u64(56); - let __v_28: G = G::from_u64(172); - let __v_29: G = G::from_u64(168); - let __v_30: G = G::from_u64(49); - let __v_31: G = G::from_u64(7); + 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)); __ptr } }; let __ret: [G; OUT_268] = [__v_32]; record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26823,38 +26774,38 @@ fn aiur_fn_269( unconstrained: bool, ) -> Result<[G; OUT_269], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(173); - let __v_1: G = G::from_u64(68); - let __v_2: G = G::from_u64(201); - let __v_3: G = G::from_u64(4); - let __v_4: G = G::from_u64(73); - let __v_5: G = G::from_u64(250); - let __v_6: G = G::from_u64(248); - let __v_7: G = G::from_u64(111); - let __v_8: G = G::from_u64(99); - let __v_9: G = G::from_u64(193); - let __v_10: G = G::from_u64(112); - let __v_11: G = G::from_u64(240); - let __v_12: G = G::from_u64(146); - let __v_13: G = G::from_u64(226); - let __v_14: G = G::from_u64(36); - let __v_15: G = G::from_u64(155); - let __v_16: G = G::from_u64(204); - let __v_17: G = G::from_u64(171); - let __v_18: G = G::from_u64(30); - let __v_19: G = G::from_u64(116); - let __v_20: G = G::from_u64(28); - let __v_21: G = G::from_u64(31); - let __v_22: G = G::from_u64(225); - let __v_23: G = G::from_u64(13); - let __v_24: G = G::from_u64(248); - let __v_25: G = G::from_u64(76); - let __v_26: G = G::from_u64(149); - let __v_27: G = G::from_u64(180); - let __v_28: G = G::from_u64(75); - let __v_29: G = G::from_u64(56); - let __v_30: G = G::from_u64(67); - let __v_31: G = G::from_u64(113); + 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)); __ptr } }; let __ret: [G; OUT_269] = [__v_32]; record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26872,38 +26823,38 @@ fn aiur_fn_270( unconstrained: bool, ) -> Result<[G; OUT_270], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(173); - let __v_1: G = G::from_u64(88); - let __v_2: G = G::from_u64(195); - let __v_3: G = G::from_u64(101); - let __v_4: G = G::from_u64(96); - let __v_5: G = G::from_u64(68); - let __v_6: G = G::from_u64(215); - let __v_7: G = G::from_u64(250); - let __v_8: G = G::from_u64(239); - let __v_9: G = G::from_u64(105); - let __v_10: G = G::from_u64(118); - let __v_11: G = G::from_u64(55); - let __v_12: G = G::from_u64(245); - let __v_13: G = G::from_u64(22); - let __v_14: G = G::from_u64(215); - let __v_15: G = G::from_u64(38); - let __v_16: G = G::from_u64(116); - let __v_17: G = G::from_u64(211); - let __v_18: G = G::from_u64(91); - let __v_19: G = G::from_u64(24); - let __v_20: G = G::from_u64(102); - let __v_21: G = G::from_u64(60); - let __v_22: G = G::from_u64(178); - let __v_23: G = G::from_u64(99); - let __v_24: G = G::from_u64(247); - let __v_25: G = G::from_u64(204); - let __v_26: G = G::from_u64(202); - let __v_27: G = G::from_u64(140); - let __v_28: G = G::from_u64(221); - let __v_29: G = G::from_u64(46); - let __v_30: G = G::from_u64(111); - let __v_31: G = G::from_u64(0); + 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)); __ptr } }; let __ret: [G; OUT_270] = [__v_32]; record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26921,38 +26872,38 @@ fn aiur_fn_271( unconstrained: bool, ) -> Result<[G; OUT_271], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(72); - let __v_1: G = G::from_u64(145); - let __v_2: G = G::from_u64(135); - let __v_3: G = G::from_u64(233); - let __v_4: G = G::from_u64(205); - let __v_5: G = G::from_u64(3); - let __v_6: G = G::from_u64(171); - let __v_7: G = G::from_u64(235); - let __v_8: G = G::from_u64(193); - let __v_9: G = G::from_u64(42); - let __v_10: G = G::from_u64(19); - let __v_11: G = G::from_u64(53); - let __v_12: G = G::from_u64(198); - let __v_13: G = G::from_u64(40); - let __v_14: G = G::from_u64(214); - let __v_15: G = G::from_u64(66); - let __v_16: G = G::from_u64(234); - let __v_17: G = G::from_u64(42); - let __v_18: G = G::from_u64(72); - let __v_19: G = G::from_u64(189); - let __v_20: G = G::from_u64(194); - let __v_21: G = G::from_u64(98); - let __v_22: G = G::from_u64(200); - let __v_23: G = G::from_u64(95); - let __v_24: G = G::from_u64(132); - let __v_25: G = G::from_u64(143); - let __v_26: G = G::from_u64(16); - let __v_27: G = G::from_u64(17); - let __v_28: G = G::from_u64(231); - let __v_29: G = G::from_u64(63); - let __v_30: G = G::from_u64(97); - let __v_31: G = G::from_u64(10); + let __v_0: G = G::from_u64(123); + let __v_1: G = G::from_u64(216); + let __v_2: G = G::from_u64(225); + let __v_3: G = G::from_u64(159); + let __v_4: G = G::from_u64(71); + let __v_5: G = G::from_u64(246); + let __v_6: G = G::from_u64(234); + let __v_7: G = G::from_u64(230); + let __v_8: G = G::from_u64(32); + let __v_9: G = G::from_u64(165); + let __v_10: G = G::from_u64(195); + let __v_11: G = G::from_u64(159); + let __v_12: G = G::from_u64(36); + let __v_13: G = G::from_u64(60); + let __v_14: G = G::from_u64(228); + let __v_15: G = G::from_u64(21); + let __v_16: G = G::from_u64(221); + let __v_17: G = G::from_u64(106); + let __v_18: G = G::from_u64(119); + let __v_19: G = G::from_u64(240); + let __v_20: G = G::from_u64(149); + let __v_21: G = G::from_u64(144); + let __v_22: G = G::from_u64(244); + let __v_23: G = G::from_u64(194); + let __v_24: G = G::from_u64(39); + let __v_25: G = G::from_u64(206); + let __v_26: G = G::from_u64(243); + let __v_27: G = G::from_u64(99); + let __v_28: G = G::from_u64(0); + 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 __ret: [G; OUT_271] = [__v_32]; record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -26970,38 +26921,38 @@ fn aiur_fn_272( unconstrained: bool, ) -> Result<[G; OUT_272], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(113); - let __v_1: G = G::from_u64(5); - let __v_2: G = G::from_u64(234); - let __v_3: G = G::from_u64(244); - let __v_4: G = G::from_u64(197); - let __v_5: G = G::from_u64(44); - let __v_6: G = G::from_u64(227); - let __v_7: G = G::from_u64(161); - let __v_8: G = G::from_u64(147); - let __v_9: G = G::from_u64(114); - let __v_10: G = G::from_u64(168); - let __v_11: G = G::from_u64(127); - let __v_12: G = G::from_u64(172); - let __v_13: G = G::from_u64(87); - let __v_14: G = G::from_u64(168); - let __v_15: G = G::from_u64(249); - let __v_16: G = G::from_u64(89); - let __v_17: G = G::from_u64(138); - let __v_18: G = G::from_u64(36); - let __v_19: G = G::from_u64(99); - let __v_20: G = G::from_u64(52); - let __v_21: G = G::from_u64(206); - let __v_22: G = G::from_u64(110); - let __v_23: G = G::from_u64(255); - let __v_24: G = G::from_u64(174); - let __v_25: G = G::from_u64(227); - let __v_26: G = G::from_u64(228); - let __v_27: G = G::from_u64(142); - let __v_28: G = G::from_u64(126); - let __v_29: G = G::from_u64(109); - let __v_30: G = G::from_u64(58); - let __v_31: G = G::from_u64(173); + 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)); __ptr } }; let __ret: [G; OUT_272] = [__v_32]; record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27019,38 +26970,38 @@ fn aiur_fn_273( unconstrained: bool, ) -> Result<[G; OUT_273], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(22); - let __v_1: G = G::from_u64(162); - let __v_2: G = G::from_u64(220); - let __v_3: G = G::from_u64(118); - let __v_4: G = G::from_u64(162); - let __v_5: G = G::from_u64(207); - let __v_6: G = G::from_u64(204); - let __v_7: G = G::from_u64(148); - let __v_8: G = G::from_u64(64); - let __v_9: G = G::from_u64(244); - let __v_10: G = G::from_u64(67); - let __v_11: G = G::from_u64(198); - let __v_12: G = G::from_u64(102); - let __v_13: G = G::from_u64(83); - let __v_14: G = G::from_u64(111); - let __v_15: G = G::from_u64(47); - let __v_16: G = G::from_u64(169); - let __v_17: G = G::from_u64(156); - let __v_18: G = G::from_u64(2); - let __v_19: G = G::from_u64(80); - let __v_20: G = G::from_u64(182); - let __v_21: G = G::from_u64(66); - let __v_22: G = G::from_u64(253); - let __v_23: G = G::from_u64(57); - let __v_24: G = G::from_u64(113); - let __v_25: G = G::from_u64(251); - let __v_26: G = G::from_u64(173); - let __v_27: G = G::from_u64(37); - let __v_28: G = G::from_u64(213); - let __v_29: G = G::from_u64(49); - let __v_30: G = G::from_u64(38); - let __v_31: G = G::from_u64(42); + let __v_0: G = G::from_u64(45); + let __v_1: G = G::from_u64(252); + let __v_2: G = G::from_u64(22); + let __v_3: G = G::from_u64(175); + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(184); + let __v_6: G = G::from_u64(43); + let __v_7: G = G::from_u64(59); + let __v_8: G = G::from_u64(145); + let __v_9: G = G::from_u64(194); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(112); + let __v_12: G = G::from_u64(68); + let __v_13: G = G::from_u64(9); + let __v_14: G = G::from_u64(215); + let __v_15: G = G::from_u64(98); + let __v_16: G = G::from_u64(54); + let __v_17: G = G::from_u64(168); + let __v_18: G = G::from_u64(63); + let __v_19: G = G::from_u64(149); + let __v_20: G = G::from_u64(108); + let __v_21: G = G::from_u64(12); + let __v_22: G = G::from_u64(110); + let __v_23: G = G::from_u64(102); + let __v_24: G = G::from_u64(89); + let __v_25: G = G::from_u64(166); + let __v_26: G = G::from_u64(79); + let __v_27: G = G::from_u64(226); + let __v_28: G = G::from_u64(29); + 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 __ret: [G; OUT_273] = [__v_32]; record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27068,38 +27019,38 @@ fn aiur_fn_274( unconstrained: bool, ) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(33); - let __v_1: G = G::from_u64(27); - let __v_2: G = G::from_u64(245); - let __v_3: G = G::from_u64(237); - let __v_4: G = G::from_u64(47); - let __v_5: G = G::from_u64(76); - let __v_6: G = G::from_u64(81); - let __v_7: G = G::from_u64(212); - let __v_8: G = G::from_u64(87); - let __v_9: G = G::from_u64(80); - let __v_10: G = G::from_u64(231); - let __v_11: G = G::from_u64(91); - let __v_12: G = G::from_u64(137); - let __v_13: G = G::from_u64(31); - let __v_14: G = G::from_u64(162); - let __v_15: G = G::from_u64(103); - let __v_16: G = G::from_u64(219); - let __v_17: G = G::from_u64(77); - let __v_18: G = G::from_u64(78); - let __v_19: G = G::from_u64(111); - let __v_20: G = G::from_u64(70); - let __v_21: G = G::from_u64(194); - let __v_22: G = G::from_u64(7); - let __v_23: G = G::from_u64(146); - let __v_24: G = G::from_u64(130); - let __v_25: G = G::from_u64(250); - let __v_26: G = G::from_u64(43); - let __v_27: G = G::from_u64(227); - let __v_28: G = G::from_u64(232); - let __v_29: G = G::from_u64(135); - let __v_30: G = G::from_u64(129); - let __v_31: G = G::from_u64(161); + let __v_0: G = G::from_u64(146); + let __v_1: G = G::from_u64(50); + let __v_2: G = G::from_u64(73); + let __v_3: G = G::from_u64(134); + let __v_4: G = G::from_u64(103); + let __v_5: G = G::from_u64(247); + let __v_6: G = G::from_u64(101); + let __v_7: G = G::from_u64(244); + let __v_8: G = G::from_u64(55); + let __v_9: G = G::from_u64(222); + let __v_10: G = G::from_u64(218); + let __v_11: G = G::from_u64(172); + let __v_12: G = G::from_u64(130); + let __v_13: G = G::from_u64(142); + let __v_14: G = G::from_u64(85); + let __v_15: G = G::from_u64(95); + let __v_16: G = G::from_u64(108); + let __v_17: G = G::from_u64(198); + let __v_18: G = G::from_u64(122); + let __v_19: G = G::from_u64(32); + let __v_20: G = G::from_u64(230); + let __v_21: G = G::from_u64(219); + let __v_22: G = G::from_u64(40); + let __v_23: G = G::from_u64(246); + let __v_24: G = G::from_u64(20); + let __v_25: G = G::from_u64(253); + let __v_26: G = G::from_u64(243); + let __v_27: G = G::from_u64(194); + let __v_28: G = G::from_u64(98); + 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 __ret: [G; OUT_274] = [__v_32]; record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27117,38 +27068,38 @@ fn aiur_fn_275( unconstrained: bool, ) -> Result<[G; OUT_275], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(252); - let __v_1: G = G::from_u64(14); - let __v_2: G = G::from_u64(30); - let __v_3: G = G::from_u64(145); - let __v_4: G = G::from_u64(47); - let __v_5: G = G::from_u64(45); - let __v_6: G = G::from_u64(127); - let __v_7: G = G::from_u64(18); - let __v_8: G = G::from_u64(4); - let __v_9: G = G::from_u64(154); - let __v_10: G = G::from_u64(91); - let __v_11: G = G::from_u64(49); - let __v_12: G = G::from_u64(93); - let __v_13: G = G::from_u64(118); - let __v_14: G = G::from_u64(238); - let __v_15: G = G::from_u64(194); - let __v_16: G = G::from_u64(149); - let __v_17: G = G::from_u64(98); - let __v_18: G = G::from_u64(227); - let __v_19: G = G::from_u64(77); - let __v_20: G = G::from_u64(195); - let __v_21: G = G::from_u64(158); - let __v_22: G = G::from_u64(188); - let __v_23: G = G::from_u64(162); - let __v_24: G = G::from_u64(82); - let __v_25: G = G::from_u64(135); - let __v_26: G = G::from_u64(174); - let __v_27: G = G::from_u64(88); - let __v_28: G = G::from_u64(128); - let __v_29: G = G::from_u64(125); - let __v_30: G = G::from_u64(177); - let __v_31: G = G::from_u64(55); + let __v_0: G = G::from_u64(57); + let __v_1: G = G::from_u64(138); + let __v_2: G = G::from_u64(119); + let __v_3: G = G::from_u64(6); + let __v_4: G = G::from_u64(207); + let __v_5: G = G::from_u64(19); + let __v_6: G = G::from_u64(242); + let __v_7: G = G::from_u64(35); + let __v_8: G = G::from_u64(153); + let __v_9: G = G::from_u64(45); + let __v_10: G = G::from_u64(23); + let __v_11: G = G::from_u64(61); + let __v_12: G = G::from_u64(206); + let __v_13: G = G::from_u64(7); + let __v_14: G = G::from_u64(148); + let __v_15: G = G::from_u64(104); + let __v_16: G = G::from_u64(87); + let __v_17: G = G::from_u64(36); + let __v_18: G = G::from_u64(15); + let __v_19: G = G::from_u64(73); + let __v_20: G = G::from_u64(175); + let __v_21: G = G::from_u64(204); + let __v_22: G = G::from_u64(116); + let __v_23: G = G::from_u64(55); + let __v_24: G = G::from_u64(35); + let __v_25: G = G::from_u64(232); + let __v_26: G = G::from_u64(57); + let __v_27: G = G::from_u64(248); + let __v_28: G = G::from_u64(243); + 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_275] = [__v_32]; record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27166,38 +27117,38 @@ fn aiur_fn_276( unconstrained: bool, ) -> Result<[G; OUT_276], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(250); - let __v_1: G = G::from_u64(200); - let __v_2: G = G::from_u64(47); - let __v_3: G = G::from_u64(13); - let __v_4: G = G::from_u64(37); - let __v_5: G = G::from_u64(85); - let __v_6: G = G::from_u64(214); - let __v_7: G = G::from_u64(166); - let __v_8: G = G::from_u64(62); - let __v_9: G = G::from_u64(27); - let __v_10: G = G::from_u64(138); - let __v_11: G = G::from_u64(31); - let __v_12: G = G::from_u64(232); - let __v_13: G = G::from_u64(216); - let __v_14: G = G::from_u64(107); - let __v_15: G = G::from_u64(210); - let __v_16: G = G::from_u64(147); - let __v_17: G = G::from_u64(25); - let __v_18: G = G::from_u64(127); - let __v_19: G = G::from_u64(57); - let __v_20: G = G::from_u64(195); - let __v_21: G = G::from_u64(150); - let __v_22: G = G::from_u64(253); - let __v_23: G = G::from_u64(194); - let __v_24: G = G::from_u64(60); - let __v_25: G = G::from_u64(18); - let __v_26: G = G::from_u64(117); - let __v_27: G = G::from_u64(198); - let __v_28: G = G::from_u64(15); - let __v_29: G = G::from_u64(24); - let __v_30: G = G::from_u64(43); - let __v_31: G = G::from_u64(55); + let __v_0: G = G::from_u64(211); + let __v_1: G = G::from_u64(151); + let __v_2: G = G::from_u64(55); + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(87); + let __v_5: G = G::from_u64(251); + let __v_6: G = G::from_u64(154); + let __v_7: G = G::from_u64(226); + let __v_8: G = G::from_u64(198); + let __v_9: G = G::from_u64(225); + let __v_10: G = G::from_u64(237); + let __v_11: G = G::from_u64(167); + let __v_12: G = G::from_u64(159); + let __v_13: G = G::from_u64(235); + let __v_14: G = G::from_u64(16); + let __v_15: G = G::from_u64(191); + let __v_16: G = G::from_u64(73); + let __v_17: G = G::from_u64(116); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(116); + let __v_20: G = G::from_u64(26); + let __v_21: G = G::from_u64(186); + let __v_22: G = G::from_u64(120); + let __v_23: G = G::from_u64(143); + let __v_24: G = G::from_u64(171); + let __v_25: G = G::from_u64(114); + let __v_26: G = G::from_u64(108); + let __v_27: G = G::from_u64(250); + let __v_28: G = G::from_u64(76); + 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 __ret: [G; OUT_276] = [__v_32]; record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27215,38 +27166,38 @@ fn aiur_fn_277( unconstrained: bool, ) -> Result<[G; OUT_277], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(113); - let __v_1: G = G::from_u64(144); - let __v_2: G = G::from_u64(206); - let __v_3: G = G::from_u64(86); - let __v_4: G = G::from_u64(246); - let __v_5: G = G::from_u64(162); - let __v_6: G = G::from_u64(168); - let __v_7: G = G::from_u64(71); - let __v_8: G = G::from_u64(185); - let __v_9: G = G::from_u64(68); - let __v_10: G = G::from_u64(163); - let __v_11: G = G::from_u64(85); - let __v_12: G = G::from_u64(227); - let __v_13: G = G::from_u64(236); - let __v_14: G = G::from_u64(89); - let __v_15: G = G::from_u64(90); - let __v_16: G = G::from_u64(64); - let __v_17: G = G::from_u64(54); - let __v_18: G = G::from_u64(251); - let __v_19: G = G::from_u64(7); - let __v_20: G = G::from_u64(227); - let __v_21: G = G::from_u64(195); - let __v_22: G = G::from_u64(219); - let __v_23: G = G::from_u64(157); - let __v_24: G = G::from_u64(144); - let __v_25: G = G::from_u64(100); - let __v_26: G = G::from_u64(252); - let __v_27: G = G::from_u64(4); - let __v_28: G = G::from_u64(27); - let __v_29: G = G::from_u64(231); - let __v_30: G = G::from_u64(43); - let __v_31: G = G::from_u64(100); + let __v_0: G = G::from_u64(222); + let __v_1: G = G::from_u64(245); + let __v_2: G = G::from_u64(45); + let __v_3: G = G::from_u64(29); + let __v_4: G = G::from_u64(173); + let __v_5: G = G::from_u64(95); + let __v_6: G = G::from_u64(16); + let __v_7: G = G::from_u64(207); + let __v_8: G = G::from_u64(152); + let __v_9: G = G::from_u64(147); + let __v_10: G = G::from_u64(201); + let __v_11: G = G::from_u64(69); + let __v_12: G = G::from_u64(225); + let __v_13: G = G::from_u64(105); + let __v_14: G = G::from_u64(113); + let __v_15: G = G::from_u64(141); + let __v_16: G = G::from_u64(98); + let __v_17: G = G::from_u64(177); + let __v_18: G = G::from_u64(94); + let __v_19: G = G::from_u64(45); + let __v_20: G = G::from_u64(210); + let __v_21: G = G::from_u64(201); + let __v_22: G = G::from_u64(6); + let __v_23: G = G::from_u64(110); + let __v_24: G = G::from_u64(89); + let __v_25: G = G::from_u64(123); + let __v_26: G = G::from_u64(157); + let __v_27: G = G::from_u64(69); + let __v_28: G = G::from_u64(112); + 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 __ret: [G; OUT_277] = [__v_32]; record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27264,38 +27215,38 @@ fn aiur_fn_278( unconstrained: bool, ) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(78); - let __v_1: G = G::from_u64(213); - let __v_2: G = G::from_u64(255); - let __v_3: G = G::from_u64(251); - let __v_4: G = G::from_u64(3); - let __v_5: G = G::from_u64(174); - let __v_6: G = G::from_u64(94); - let __v_7: G = G::from_u64(107); - let __v_8: G = G::from_u64(122); - let __v_9: G = G::from_u64(13); - let __v_10: G = G::from_u64(159); - let __v_11: G = G::from_u64(51); - let __v_12: G = G::from_u64(121); - let __v_13: G = G::from_u64(170); - let __v_14: G = G::from_u64(118); - let __v_15: G = G::from_u64(158); - let __v_16: G = G::from_u64(92); - let __v_17: G = G::from_u64(168); - let __v_18: G = G::from_u64(24); - let __v_19: G = G::from_u64(140); - let __v_20: G = G::from_u64(172); - let __v_21: G = G::from_u64(189); - let __v_22: G = G::from_u64(241); - let __v_23: G = G::from_u64(226); - let __v_24: G = G::from_u64(13); - let __v_25: G = G::from_u64(202); - let __v_26: G = G::from_u64(75); - let __v_27: G = G::from_u64(173); - let __v_28: G = G::from_u64(39); - let __v_29: G = G::from_u64(242); - let __v_30: G = G::from_u64(83); - let __v_31: G = G::from_u64(51); + let __v_0: G = G::from_u64(145); + let __v_1: G = G::from_u64(79); + let __v_2: G = G::from_u64(156); + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(136); + let __v_5: G = G::from_u64(72); + let __v_6: G = G::from_u64(83); + let __v_7: G = G::from_u64(101); + let __v_8: G = G::from_u64(46); + let __v_9: G = G::from_u64(146); + let __v_10: G = G::from_u64(36); + let __v_11: G = G::from_u64(220); + let __v_12: G = G::from_u64(81); + let __v_13: G = G::from_u64(31); + let __v_14: G = G::from_u64(134); + let __v_15: G = G::from_u64(125); + let __v_16: G = G::from_u64(84); + let __v_17: G = G::from_u64(8); + let __v_18: G = G::from_u64(81); + let __v_19: G = G::from_u64(127); + let __v_20: G = G::from_u64(59); + let __v_21: G = G::from_u64(235); + let __v_22: G = G::from_u64(49); + let __v_23: G = G::from_u64(146); + let __v_24: G = G::from_u64(252); + let __v_25: G = G::from_u64(68); + let __v_26: G = G::from_u64(119); + let __v_27: G = G::from_u64(224); + let __v_28: G = G::from_u64(233); + 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 __ret: [G; OUT_278] = [__v_32]; record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27313,38 +27264,38 @@ fn aiur_fn_279( unconstrained: bool, ) -> Result<[G; OUT_279], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(157); - let __v_1: G = G::from_u64(131); - let __v_2: G = G::from_u64(48); - let __v_3: G = G::from_u64(125); - let __v_4: G = G::from_u64(85); - let __v_5: G = G::from_u64(46); - let __v_6: G = G::from_u64(104); - let __v_7: G = G::from_u64(31); - let __v_8: G = G::from_u64(76); - let __v_9: G = G::from_u64(206); - let __v_10: G = G::from_u64(255); - let __v_11: G = G::from_u64(127); - let __v_12: G = G::from_u64(120); - let __v_13: G = G::from_u64(59); - let __v_14: G = G::from_u64(90); - let __v_15: G = G::from_u64(100); - let __v_16: G = G::from_u64(224); - let __v_17: G = G::from_u64(2); - let __v_18: G = G::from_u64(87); - let __v_19: G = G::from_u64(94); - let __v_20: G = G::from_u64(220); - let __v_21: G = G::from_u64(177); - let __v_22: G = G::from_u64(192); - let __v_23: G = G::from_u64(79); - let __v_24: G = G::from_u64(160); - let __v_25: G = G::from_u64(197); - let __v_26: G = G::from_u64(102); - let __v_27: G = G::from_u64(44); - let __v_28: G = G::from_u64(226); - let __v_29: G = G::from_u64(221); - let __v_30: G = G::from_u64(52); - let __v_31: G = G::from_u64(56); + 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)); __ptr } }; let __ret: [G; OUT_279] = [__v_32]; record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27362,38 +27313,38 @@ fn aiur_fn_280( unconstrained: bool, ) -> Result<[G; OUT_280], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(158); - let __v_1: G = G::from_u64(134); - let __v_2: G = G::from_u64(255); - let __v_3: G = G::from_u64(67); - let __v_4: G = G::from_u64(177); - let __v_5: G = G::from_u64(90); - let __v_6: G = G::from_u64(235); - let __v_7: G = G::from_u64(175); - let __v_8: G = G::from_u64(179); - let __v_9: G = G::from_u64(223); - let __v_10: G = G::from_u64(97); - let __v_11: G = G::from_u64(10); - let __v_12: G = G::from_u64(150); - let __v_13: G = G::from_u64(221); - let __v_14: G = G::from_u64(68); - let __v_15: G = G::from_u64(146); - let __v_16: G = G::from_u64(255); - let __v_17: G = G::from_u64(156); - let __v_18: G = G::from_u64(216); - let __v_19: G = G::from_u64(170); - let __v_20: G = G::from_u64(184); - let __v_21: G = G::from_u64(122); - let __v_22: G = G::from_u64(130); - let __v_23: G = G::from_u64(2); - let __v_24: G = G::from_u64(91); - let __v_25: G = G::from_u64(97); - let __v_26: G = G::from_u64(124); - let __v_27: G = G::from_u64(154); - let __v_28: G = G::from_u64(11); - let __v_29: G = G::from_u64(191); - let __v_30: G = G::from_u64(98); - let __v_31: G = G::from_u64(128); + 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)); __ptr } }; let __ret: [G; OUT_280] = [__v_32]; record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27411,38 +27362,38 @@ fn aiur_fn_281( unconstrained: bool, ) -> Result<[G; OUT_281], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(155); - let __v_1: G = G::from_u64(193); - let __v_2: G = G::from_u64(53); - let __v_3: G = G::from_u64(57); - let __v_4: G = G::from_u64(182); - let __v_5: G = G::from_u64(139); - let __v_6: G = G::from_u64(14); - let __v_7: G = G::from_u64(28); - let __v_8: G = G::from_u64(90); - let __v_9: G = G::from_u64(83); - let __v_10: G = G::from_u64(129); - let __v_11: G = G::from_u64(133); - let __v_12: G = G::from_u64(128); - let __v_13: G = G::from_u64(170); - let __v_14: G = G::from_u64(9); - let __v_15: G = G::from_u64(106); - let __v_16: G = G::from_u64(101); - let __v_17: G = G::from_u64(144); - let __v_18: G = G::from_u64(127); - let __v_19: G = G::from_u64(99); - let __v_20: G = G::from_u64(175); - let __v_21: G = G::from_u64(69); - let __v_22: G = G::from_u64(136); - let __v_23: G = G::from_u64(161); - let __v_24: G = G::from_u64(233); - let __v_25: G = G::from_u64(30); - let __v_26: G = G::from_u64(20); - let __v_27: G = G::from_u64(211); - let __v_28: G = G::from_u64(77); - let __v_29: G = G::from_u64(158); - let __v_30: G = G::from_u64(77); - let __v_31: G = G::from_u64(134); + 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)); __ptr } }; let __ret: [G; OUT_281] = [__v_32]; record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27460,38 +27411,38 @@ fn aiur_fn_282( unconstrained: bool, ) -> Result<[G; OUT_282], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(181); - let __v_1: G = G::from_u64(44); - let __v_2: G = G::from_u64(77); - let __v_3: G = G::from_u64(13); - let __v_4: G = G::from_u64(56); - let __v_5: G = G::from_u64(120); - let __v_6: G = G::from_u64(242); - let __v_7: G = G::from_u64(135); - let __v_8: G = G::from_u64(113); - let __v_9: G = G::from_u64(159); - let __v_10: G = G::from_u64(101); - let __v_11: G = G::from_u64(208); - let __v_12: G = G::from_u64(8); - let __v_13: G = G::from_u64(138); - let __v_14: G = G::from_u64(38); - let __v_15: G = G::from_u64(154); - let __v_16: G = G::from_u64(240); - let __v_17: G = G::from_u64(246); - let __v_18: G = G::from_u64(229); - let __v_19: G = G::from_u64(177); + 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(239); - let __v_22: G = G::from_u64(86); - let __v_23: G = G::from_u64(41); - let __v_24: G = G::from_u64(131); - let __v_25: G = G::from_u64(9); - let __v_26: G = G::from_u64(99); - let __v_27: G = G::from_u64(220); - let __v_28: G = G::from_u64(183); - let __v_29: G = G::from_u64(94); - let __v_30: G = G::from_u64(108); - let __v_31: G = G::from_u64(238); + 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)); __ptr } }; let __ret: [G; OUT_282] = [__v_32]; record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27509,38 +27460,38 @@ fn aiur_fn_283( unconstrained: bool, ) -> Result<[G; OUT_283], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(116); - let __v_1: G = G::from_u64(54); - let __v_2: G = G::from_u64(217); - let __v_3: G = G::from_u64(250); - let __v_4: G = G::from_u64(124); - let __v_5: G = G::from_u64(206); - let __v_6: G = G::from_u64(62); - let __v_7: G = G::from_u64(249); - let __v_8: G = G::from_u64(27); - let __v_9: G = G::from_u64(201); - let __v_10: G = G::from_u64(144); - let __v_11: G = G::from_u64(60); - let __v_12: G = G::from_u64(197); - let __v_13: G = G::from_u64(170); - let __v_14: G = G::from_u64(50); - let __v_15: G = G::from_u64(212); - let __v_16: G = G::from_u64(19); - let __v_17: G = G::from_u64(218); - let __v_18: G = G::from_u64(47); - let __v_19: G = G::from_u64(108); - let __v_20: G = G::from_u64(167); - let __v_21: G = G::from_u64(194); - let __v_22: G = G::from_u64(26); - let __v_23: G = G::from_u64(146); - let __v_24: G = G::from_u64(53); - let __v_25: G = G::from_u64(180); - let __v_26: G = G::from_u64(26); - let __v_27: G = G::from_u64(47); - let __v_28: G = G::from_u64(196); - let __v_29: G = G::from_u64(130); - let __v_30: G = G::from_u64(223); - let __v_31: G = G::from_u64(252); + 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)); __ptr } }; let __ret: [G; OUT_283] = [__v_32]; record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27558,38 +27509,38 @@ fn aiur_fn_284( unconstrained: bool, ) -> Result<[G; OUT_284], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(110); - let __v_1: G = G::from_u64(161); - let __v_2: G = G::from_u64(164); - let __v_3: G = G::from_u64(79); - let __v_4: G = G::from_u64(115); - let __v_5: G = G::from_u64(120); - let __v_6: G = G::from_u64(227); - let __v_7: G = G::from_u64(114); - let __v_8: G = G::from_u64(254); - let __v_9: G = G::from_u64(181); - let __v_10: G = G::from_u64(143); - let __v_11: G = G::from_u64(181); - let __v_12: G = G::from_u64(44); - let __v_13: G = G::from_u64(128); - let __v_14: G = G::from_u64(132); - let __v_15: G = G::from_u64(98); - let __v_16: G = G::from_u64(96); - let __v_17: G = G::from_u64(87); - let __v_18: G = G::from_u64(179); - let __v_19: G = G::from_u64(243); - let __v_20: G = G::from_u64(135); - let __v_21: G = G::from_u64(73); - let __v_22: G = G::from_u64(94); - let __v_23: G = G::from_u64(118); - let __v_24: G = G::from_u64(0); - let __v_25: G = G::from_u64(185); - let __v_26: G = G::from_u64(113); - let __v_27: G = G::from_u64(163); - let __v_28: G = G::from_u64(139); - let __v_29: G = G::from_u64(36); - let __v_30: G = G::from_u64(66); - let __v_31: G = G::from_u64(118); + 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)); __ptr } }; let __ret: [G; OUT_284] = [__v_32]; record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27607,38 +27558,38 @@ fn aiur_fn_285( unconstrained: bool, ) -> Result<[G; OUT_285], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(208); - let __v_1: G = G::from_u64(145); - let __v_2: G = G::from_u64(149); - let __v_3: G = G::from_u64(112); - let __v_4: G = G::from_u64(248); - let __v_5: G = G::from_u64(147); - let __v_6: G = G::from_u64(45); - let __v_7: G = G::from_u64(223); - let __v_8: G = G::from_u64(93); - let __v_9: G = G::from_u64(255); - let __v_10: G = G::from_u64(67); - let __v_11: G = G::from_u64(0); - let __v_12: G = G::from_u64(171); - let __v_13: G = G::from_u64(118); - let __v_14: G = G::from_u64(103); - let __v_15: G = G::from_u64(209); - let __v_16: G = G::from_u64(186); - let __v_17: G = G::from_u64(171); - let __v_18: G = G::from_u64(147); - let __v_19: G = G::from_u64(36); - let __v_20: G = G::from_u64(219); - let __v_21: G = G::from_u64(193); - let __v_22: G = G::from_u64(54); - let __v_23: G = G::from_u64(172); - let __v_24: G = G::from_u64(156); - let __v_25: G = G::from_u64(129); - let __v_26: G = G::from_u64(41); - let __v_27: G = G::from_u64(46); - let __v_28: G = G::from_u64(209); - let __v_29: G = G::from_u64(200); - let __v_30: G = G::from_u64(31); - let __v_31: G = G::from_u64(233); + 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)); __ptr } }; let __ret: [G; OUT_285] = [__v_32]; record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27656,38 +27607,38 @@ fn aiur_fn_286( unconstrained: bool, ) -> Result<[G; OUT_286], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(68); - let __v_1: G = G::from_u64(81); - let __v_2: G = G::from_u64(67); - let __v_3: G = G::from_u64(32); - let __v_4: G = G::from_u64(189); - let __v_5: G = G::from_u64(147); - let __v_6: G = G::from_u64(53); - let __v_7: G = G::from_u64(160); - let __v_8: G = G::from_u64(137); - let __v_9: G = G::from_u64(66); - let __v_10: G = G::from_u64(231); - let __v_11: G = G::from_u64(125); - let __v_12: G = G::from_u64(232); - let __v_13: G = G::from_u64(7); - let __v_14: G = G::from_u64(126); - let __v_15: G = G::from_u64(56); - let __v_16: G = G::from_u64(63); - let __v_17: G = G::from_u64(17); - let __v_18: G = G::from_u64(160); - let __v_19: G = G::from_u64(246); - let __v_20: G = G::from_u64(21); - let __v_21: G = G::from_u64(12); - let __v_22: G = G::from_u64(0); - let __v_23: G = G::from_u64(12); - let __v_24: G = G::from_u64(152); - let __v_25: G = G::from_u64(35); - let __v_26: G = G::from_u64(200); - let __v_27: G = G::from_u64(116); - let __v_28: G = G::from_u64(103); - let __v_29: G = G::from_u64(88); - let __v_30: G = G::from_u64(153); - let __v_31: G = G::from_u64(101); + 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)); __ptr } }; let __ret: [G; OUT_286] = [__v_32]; record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27704,39 +27655,39 @@ fn aiur_fn_287( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_287], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(24); - let __v_1: G = G::from_u64(76); - let __v_2: G = G::from_u64(166); - let __v_3: G = G::from_u64(169); - let __v_4: G = G::from_u64(50); - let __v_5: G = G::from_u64(164); - let __v_6: G = G::from_u64(197); - let __v_7: G = G::from_u64(253); - let __v_8: G = G::from_u64(10); - let __v_9: G = G::from_u64(44); - let __v_10: G = G::from_u64(22); - let __v_11: G = G::from_u64(149); - let __v_12: G = G::from_u64(1); - let __v_13: G = G::from_u64(210); - let __v_14: G = G::from_u64(213); - let __v_15: G = G::from_u64(4); - let __v_16: G = G::from_u64(139); - let __v_17: G = G::from_u64(183); - let __v_18: G = G::from_u64(67); - let __v_19: G = G::from_u64(189); - let __v_20: G = G::from_u64(22); - let __v_21: G = G::from_u64(111); - let __v_22: G = G::from_u64(150); - let __v_23: G = G::from_u64(255); - let __v_24: G = G::from_u64(236); - let __v_25: G = G::from_u64(157); - let __v_26: G = G::from_u64(65); - let __v_27: G = G::from_u64(1); - let __v_28: G = G::from_u64(229); + 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(152); - let __v_31: G = G::from_u64(43); + 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)); __ptr } }; let __ret: [G; OUT_287] = [__v_32]; record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27754,38 +27705,38 @@ fn aiur_fn_288( unconstrained: bool, ) -> Result<[G; OUT_288], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(22); - let __v_1: G = G::from_u64(58); - let __v_2: G = G::from_u64(140); - let __v_3: G = G::from_u64(40); - let __v_4: G = G::from_u64(0); - let __v_5: G = G::from_u64(202); - let __v_6: G = G::from_u64(81); - let __v_7: G = G::from_u64(218); - let __v_8: G = G::from_u64(175); - let __v_9: G = G::from_u64(254); - let __v_10: G = G::from_u64(27); - let __v_11: G = G::from_u64(113); - let __v_12: G = G::from_u64(87); - let __v_13: G = G::from_u64(81); - let __v_14: G = G::from_u64(39); - let __v_15: G = G::from_u64(148); - let __v_16: G = G::from_u64(42); - let __v_17: G = G::from_u64(5); - let __v_18: G = G::from_u64(48); - let __v_19: G = G::from_u64(4); - let __v_20: G = G::from_u64(64); - let __v_21: G = G::from_u64(82); - let __v_22: G = G::from_u64(75); - let __v_23: G = G::from_u64(20); - let __v_24: G = G::from_u64(92); - let __v_25: G = G::from_u64(143); - let __v_26: G = G::from_u64(205); - let __v_27: G = G::from_u64(204); - let __v_28: G = G::from_u64(94); - let __v_29: G = G::from_u64(224); - let __v_30: G = G::from_u64(8); - let __v_31: G = G::from_u64(182); + 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)); __ptr } }; let __ret: [G; OUT_288] = [__v_32]; record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27803,38 +27754,38 @@ fn aiur_fn_289( unconstrained: bool, ) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(22); - let __v_1: G = G::from_u64(189); - let __v_2: G = G::from_u64(16); - let __v_3: G = G::from_u64(54); - let __v_4: G = G::from_u64(94); - let __v_5: G = G::from_u64(230); - let __v_6: G = G::from_u64(250); - let __v_7: G = G::from_u64(64); - let __v_8: G = G::from_u64(180); - let __v_9: G = G::from_u64(161); - let __v_10: G = G::from_u64(221); - let __v_11: G = G::from_u64(192); - let __v_12: G = G::from_u64(221); - let __v_13: G = G::from_u64(38); - let __v_14: G = G::from_u64(200); - let __v_15: G = G::from_u64(164); - let __v_16: G = G::from_u64(157); - let __v_17: G = G::from_u64(184); - let __v_18: G = G::from_u64(248); - let __v_19: G = G::from_u64(177); - let __v_20: G = G::from_u64(235); - let __v_21: G = G::from_u64(86); - let __v_22: G = G::from_u64(178); - let __v_23: G = G::from_u64(172); - let __v_24: G = G::from_u64(42); - let __v_25: G = G::from_u64(23); - let __v_26: G = G::from_u64(158); - let __v_27: G = G::from_u64(162); - let __v_28: G = G::from_u64(68); - let __v_29: G = G::from_u64(5); - let __v_30: G = G::from_u64(152); - let __v_31: G = G::from_u64(215); + 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(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)); __ptr } }; let __ret: [G; OUT_289] = [__v_32]; record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27852,38 +27803,38 @@ fn aiur_fn_290( unconstrained: bool, ) -> Result<[G; OUT_290], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(111); - let __v_1: G = G::from_u64(226); - let __v_2: G = G::from_u64(30); - let __v_3: G = G::from_u64(53); - let __v_4: G = G::from_u64(169); - let __v_5: G = G::from_u64(163); - let __v_6: G = G::from_u64(8); - let __v_7: G = G::from_u64(222); - let __v_8: G = G::from_u64(175); - let __v_9: G = G::from_u64(229); - let __v_10: G = G::from_u64(50); - let __v_11: G = G::from_u64(16); - let __v_12: G = G::from_u64(219); - let __v_13: G = G::from_u64(91); - let __v_14: G = G::from_u64(40); - let __v_15: G = G::from_u64(86); - let __v_16: G = G::from_u64(193); - let __v_17: G = G::from_u64(133); - let __v_18: G = G::from_u64(220); - let __v_19: G = G::from_u64(20); - let __v_20: G = G::from_u64(126); - let __v_21: G = G::from_u64(242); - let __v_22: G = G::from_u64(113); - let __v_23: G = G::from_u64(124); - let __v_24: G = G::from_u64(14); - let __v_25: G = G::from_u64(115); - let __v_26: G = G::from_u64(160); - let __v_27: G = G::from_u64(250); - let __v_28: G = G::from_u64(58); - let __v_29: G = G::from_u64(211); - let __v_30: G = G::from_u64(22); - let __v_31: G = G::from_u64(144); + 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)); __ptr } }; let __ret: [G; OUT_290] = [__v_32]; record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27901,38 +27852,38 @@ fn aiur_fn_291( unconstrained: bool, ) -> Result<[G; OUT_291], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(73); - let __v_1: G = G::from_u64(161); - let __v_2: G = G::from_u64(103); - let __v_3: G = G::from_u64(20); - let __v_4: G = G::from_u64(189); - let __v_5: G = G::from_u64(123); - let __v_6: G = G::from_u64(130); - let __v_7: G = G::from_u64(3); - let __v_8: G = G::from_u64(124); - let __v_9: G = G::from_u64(216); - let __v_10: G = G::from_u64(231); - let __v_11: G = G::from_u64(118); - let __v_12: G = G::from_u64(51); - let __v_13: G = G::from_u64(29); - let __v_14: G = G::from_u64(130); - let __v_15: G = G::from_u64(98); - let __v_16: G = G::from_u64(130); - let __v_17: G = G::from_u64(155); - let __v_18: G = G::from_u64(199); - let __v_19: G = G::from_u64(12); - let __v_20: G = G::from_u64(142); - let __v_21: G = G::from_u64(227); - let __v_22: G = G::from_u64(99); - let __v_23: G = G::from_u64(200); - let __v_24: G = G::from_u64(102); - let __v_25: G = G::from_u64(199); - let __v_26: G = G::from_u64(6); - let __v_27: G = G::from_u64(11); - let __v_28: G = G::from_u64(243); - let __v_29: G = G::from_u64(102); - let __v_30: G = G::from_u64(205); - let __v_31: G = G::from_u64(155); + 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(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)); __ptr } }; let __ret: [G; OUT_291] = [__v_32]; record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27950,38 +27901,38 @@ fn aiur_fn_292( unconstrained: bool, ) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(245); - let __v_1: G = G::from_u64(187); - let __v_2: G = G::from_u64(36); - let __v_3: G = G::from_u64(87); - let __v_4: G = G::from_u64(103); - let __v_5: G = G::from_u64(253); - let __v_6: G = G::from_u64(188); - let __v_7: G = G::from_u64(104); - let __v_8: G = G::from_u64(59); - let __v_9: G = G::from_u64(238); - let __v_10: G = G::from_u64(158); - let __v_11: G = G::from_u64(28); - let __v_12: G = G::from_u64(168); - let __v_13: G = G::from_u64(217); - let __v_14: G = G::from_u64(167); - let __v_15: G = G::from_u64(36); - let __v_16: G = G::from_u64(116); - let __v_17: G = G::from_u64(38); - let __v_18: G = G::from_u64(251); - let __v_19: G = G::from_u64(36); - let __v_20: G = G::from_u64(198); - let __v_21: G = G::from_u64(123); - let __v_22: G = G::from_u64(44); - let __v_23: G = G::from_u64(63); - let __v_24: G = G::from_u64(34); - let __v_25: G = G::from_u64(125); - let __v_26: G = G::from_u64(229); - let __v_27: G = G::from_u64(27); - let __v_28: G = G::from_u64(95); - let __v_29: G = G::from_u64(131); - let __v_30: G = G::from_u64(155); - let __v_31: G = G::from_u64(38); + 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)); __ptr } }; let __ret: [G; OUT_292] = [__v_32]; record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -27999,38 +27950,38 @@ fn aiur_fn_293( unconstrained: bool, ) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(66); - let __v_1: G = G::from_u64(38); - let __v_2: G = G::from_u64(88); - let __v_3: G = G::from_u64(208); - let __v_4: G = G::from_u64(67); - let __v_5: G = G::from_u64(238); - let __v_6: G = G::from_u64(72); - let __v_7: G = G::from_u64(47); - let __v_8: G = G::from_u64(113); - let __v_9: G = G::from_u64(2); - let __v_10: G = G::from_u64(210); - let __v_11: G = G::from_u64(246); - let __v_12: G = G::from_u64(234); - let __v_13: G = G::from_u64(101); - let __v_14: G = G::from_u64(150); - let __v_15: G = G::from_u64(102); - let __v_16: G = G::from_u64(72); - let __v_17: G = G::from_u64(8); - let __v_18: G = G::from_u64(232); - let __v_19: G = G::from_u64(153); - let __v_20: G = G::from_u64(171); - let __v_21: G = G::from_u64(173); - let __v_22: G = G::from_u64(98); - let __v_23: G = G::from_u64(128); - let __v_24: G = G::from_u64(128); - let __v_25: G = G::from_u64(71); - let __v_26: G = G::from_u64(138); - let __v_27: G = G::from_u64(30); - let __v_28: G = G::from_u64(145); - let __v_29: G = G::from_u64(137); - let __v_30: G = G::from_u64(240); - let __v_31: G = G::from_u64(170); + 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)); __ptr } }; let __ret: [G; OUT_293] = [__v_32]; record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28048,38 +27999,38 @@ fn aiur_fn_294( unconstrained: bool, ) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(204); - let __v_1: G = G::from_u64(108); - let __v_2: G = G::from_u64(220); - let __v_3: G = G::from_u64(115); - let __v_4: G = G::from_u64(224); - let __v_5: G = G::from_u64(223); - let __v_6: G = G::from_u64(64); - let __v_7: G = G::from_u64(75); - let __v_8: G = G::from_u64(167); - let __v_9: G = G::from_u64(104); - let __v_10: G = G::from_u64(92); - let __v_11: G = G::from_u64(115); - let __v_12: G = G::from_u64(62); - let __v_13: G = G::from_u64(187); - let __v_14: G = G::from_u64(231); - let __v_15: G = G::from_u64(193); - let __v_16: G = G::from_u64(174); - let __v_17: G = G::from_u64(204); - let __v_18: G = G::from_u64(110); - let __v_19: G = G::from_u64(244); - let __v_20: G = G::from_u64(101); - let __v_21: G = G::from_u64(3); - let __v_22: G = G::from_u64(209); - let __v_23: G = G::from_u64(10); - let __v_24: G = G::from_u64(173); - let __v_25: G = G::from_u64(88); - let __v_26: G = G::from_u64(191); - let __v_27: G = G::from_u64(112); - let __v_28: G = G::from_u64(248); - let __v_29: G = G::from_u64(74); - let __v_30: G = G::from_u64(72); - let __v_31: G = G::from_u64(88); + 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)); __ptr } }; let __ret: [G; OUT_294] = [__v_32]; record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28097,38 +28048,38 @@ fn aiur_fn_295( unconstrained: bool, ) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(246); - let __v_1: G = G::from_u64(6); - let __v_2: G = G::from_u64(111); - let __v_3: G = G::from_u64(198); - let __v_4: G = G::from_u64(36); - let __v_5: G = G::from_u64(145); - let __v_6: G = G::from_u64(253); - let __v_7: G = G::from_u64(76); - let __v_8: G = G::from_u64(72); - let __v_9: G = G::from_u64(212); - let __v_10: G = G::from_u64(218); - let __v_11: G = G::from_u64(243); - let __v_12: G = G::from_u64(185); - let __v_13: G = G::from_u64(190); - let __v_14: G = G::from_u64(186); - let __v_15: G = G::from_u64(114); - let __v_16: G = G::from_u64(226); - let __v_17: G = G::from_u64(160); - let __v_18: G = G::from_u64(184); - let __v_19: G = G::from_u64(4); - let __v_20: G = G::from_u64(15); - let __v_21: G = G::from_u64(203); - let __v_22: G = G::from_u64(217); - let __v_23: G = G::from_u64(159); - let __v_24: G = G::from_u64(183); - let __v_25: G = G::from_u64(41); - let __v_26: G = G::from_u64(171); - let __v_27: G = G::from_u64(245); - let __v_28: G = G::from_u64(106); - let __v_29: G = G::from_u64(156); - let __v_30: G = G::from_u64(7); - let __v_31: G = G::from_u64(196); + 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(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)); __ptr } }; let __ret: [G; OUT_295] = [__v_32]; record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28146,38 +28097,38 @@ fn aiur_fn_296( unconstrained: bool, ) -> Result<[G; OUT_296], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(213); - let __v_1: G = G::from_u64(229); - let __v_2: G = G::from_u64(67); - let __v_3: G = G::from_u64(165); - let __v_4: G = G::from_u64(182); - let __v_5: G = G::from_u64(189); - let __v_6: G = G::from_u64(232); - let __v_7: G = G::from_u64(141); - let __v_8: G = G::from_u64(195); - let __v_9: G = G::from_u64(133); - let __v_10: G = G::from_u64(77); - let __v_11: G = G::from_u64(76); - let __v_12: G = G::from_u64(43); - let __v_13: G = G::from_u64(154); - let __v_14: G = G::from_u64(18); - let __v_15: G = G::from_u64(172); - let __v_16: G = G::from_u64(39); - let __v_17: G = G::from_u64(9); - let __v_18: G = G::from_u64(118); - let __v_19: G = G::from_u64(191); - let __v_20: G = G::from_u64(65); - let __v_21: G = G::from_u64(2); - let __v_22: G = G::from_u64(166); - let __v_23: G = G::from_u64(179); - let __v_24: G = G::from_u64(63); - let __v_25: G = G::from_u64(85); - let __v_26: G = G::from_u64(169); - let __v_27: G = G::from_u64(13); - let __v_28: G = G::from_u64(179); - let __v_29: G = G::from_u64(36); - let __v_30: G = G::from_u64(38); - let __v_31: G = G::from_u64(143); + 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)); __ptr } }; let __ret: [G; OUT_296] = [__v_32]; record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28195,38 +28146,38 @@ fn aiur_fn_297( unconstrained: bool, ) -> Result<[G; OUT_297], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(160); - let __v_1: G = G::from_u64(119); - let __v_2: G = G::from_u64(54); - let __v_3: G = G::from_u64(236); - let __v_4: G = G::from_u64(153); - let __v_5: G = G::from_u64(159); - let __v_6: G = G::from_u64(220); - let __v_7: G = G::from_u64(184); - let __v_8: G = G::from_u64(117); - let __v_9: G = G::from_u64(48); - let __v_10: G = G::from_u64(103); - let __v_11: G = G::from_u64(73); - let __v_12: G = G::from_u64(127); - let __v_13: G = G::from_u64(159); - let __v_14: G = G::from_u64(151); - let __v_15: G = G::from_u64(180); - let __v_16: G = G::from_u64(97); - let __v_17: G = G::from_u64(242); - let __v_18: G = G::from_u64(161); - let __v_19: G = G::from_u64(78); - let __v_20: G = G::from_u64(129); - let __v_21: G = G::from_u64(105); - let __v_22: G = G::from_u64(205); - let __v_23: G = G::from_u64(17); - let __v_24: G = G::from_u64(40); - let __v_25: G = G::from_u64(125); - let __v_26: G = G::from_u64(199); - let __v_27: G = G::from_u64(60); - let __v_28: G = G::from_u64(223); - let __v_29: G = G::from_u64(215); - let __v_30: G = G::from_u64(66); - let __v_31: G = G::from_u64(170); + 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)); __ptr } }; let __ret: [G; OUT_297] = [__v_32]; record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28244,38 +28195,38 @@ fn aiur_fn_298( unconstrained: bool, ) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(192); - let __v_1: G = G::from_u64(127); - let __v_2: G = G::from_u64(21); - let __v_3: G = G::from_u64(137); - let __v_4: G = G::from_u64(189); - let __v_5: G = G::from_u64(125); - let __v_6: G = G::from_u64(204); - let __v_7: G = G::from_u64(85); - let __v_8: G = G::from_u64(110); - let __v_9: G = G::from_u64(56); - let __v_10: G = G::from_u64(78); - let __v_11: G = G::from_u64(66); - let __v_12: G = G::from_u64(186); - let __v_13: G = G::from_u64(177); - let __v_14: G = G::from_u64(66); - let __v_15: G = G::from_u64(168); - let __v_16: G = G::from_u64(79); - let __v_17: G = G::from_u64(122); - let __v_18: G = G::from_u64(98); - let __v_19: G = G::from_u64(85); - let __v_20: G = G::from_u64(211); - let __v_21: G = G::from_u64(155); - let __v_22: G = G::from_u64(89); - let __v_23: G = G::from_u64(176); - let __v_24: G = G::from_u64(249); - let __v_25: G = G::from_u64(0); - let __v_26: G = G::from_u64(25); - let __v_27: G = G::from_u64(128); - let __v_28: G = G::from_u64(71); + 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(34); - let __v_31: G = G::from_u64(150); + 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)); __ptr } }; let __ret: [G; OUT_298] = [__v_32]; record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28293,38 +28244,38 @@ fn aiur_fn_299( unconstrained: bool, ) -> Result<[G; OUT_299], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(40); - let __v_1: G = G::from_u64(220); - let __v_2: G = G::from_u64(27); - let __v_3: G = G::from_u64(61); - let __v_4: G = G::from_u64(61); - let __v_5: G = G::from_u64(46); - let __v_6: G = G::from_u64(1); - let __v_7: G = G::from_u64(21); - let __v_8: G = G::from_u64(41); - let __v_9: G = G::from_u64(199); - let __v_10: G = G::from_u64(28); - let __v_11: G = G::from_u64(157); - let __v_12: G = G::from_u64(68); - let __v_13: G = G::from_u64(24); - let __v_14: G = G::from_u64(36); - let __v_15: G = G::from_u64(143); - let __v_16: G = G::from_u64(96); - let __v_17: G = G::from_u64(96); - let __v_18: G = G::from_u64(219); - let __v_19: G = G::from_u64(251); - let __v_20: G = G::from_u64(28); - let __v_21: G = G::from_u64(126); - let __v_22: G = G::from_u64(151); - let __v_23: G = G::from_u64(219); - let __v_24: G = G::from_u64(28); - let __v_25: G = G::from_u64(87); - let __v_26: G = G::from_u64(42); - let __v_27: G = G::from_u64(86); - let __v_28: G = G::from_u64(87); - let __v_29: G = G::from_u64(135); - let __v_30: G = G::from_u64(239); - let __v_31: G = G::from_u64(97); + 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(239); + let __v_8: G = G::from_u64(56); + 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_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_299] = [__v_32]; record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28342,38 +28293,38 @@ fn aiur_fn_300( unconstrained: bool, ) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(47); - let __v_1: G = G::from_u64(150); - let __v_2: G = G::from_u64(184); - let __v_3: G = G::from_u64(218); - let __v_4: G = G::from_u64(41); - let __v_5: G = G::from_u64(163); - let __v_6: G = G::from_u64(139); - let __v_7: G = G::from_u64(23); - let __v_8: G = G::from_u64(127); - let __v_9: G = G::from_u64(195); - let __v_10: G = G::from_u64(37); - let __v_11: G = G::from_u64(83); - let __v_12: G = G::from_u64(213); - let __v_13: G = G::from_u64(56); - let __v_14: G = G::from_u64(213); - let __v_15: G = G::from_u64(212); - let __v_16: G = G::from_u64(80); - let __v_17: G = G::from_u64(33); - let __v_18: G = G::from_u64(47); - let __v_19: G = G::from_u64(211); - let __v_20: G = G::from_u64(230); - let __v_21: G = G::from_u64(254); - let __v_22: G = G::from_u64(217); - let __v_23: G = G::from_u64(93); - let __v_24: G = G::from_u64(97); - let __v_25: G = G::from_u64(200); - let __v_26: G = G::from_u64(23); - let __v_27: G = G::from_u64(131); - let __v_28: G = G::from_u64(125); - let __v_29: G = G::from_u64(41); - let __v_30: G = G::from_u64(163); - let __v_31: G = G::from_u64(79); + 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)); __ptr } }; let __ret: [G; OUT_300] = [__v_32]; record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28391,38 +28342,38 @@ fn aiur_fn_301( unconstrained: bool, ) -> Result<[G; OUT_301], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(64); - let __v_1: G = G::from_u64(93); - let __v_2: G = G::from_u64(54); - let __v_3: G = G::from_u64(245); - let __v_4: G = G::from_u64(246); - let __v_5: G = G::from_u64(71); - let __v_6: G = G::from_u64(156); - let __v_7: G = G::from_u64(64); - let __v_8: G = G::from_u64(33); - let __v_9: G = G::from_u64(111); - let __v_10: G = G::from_u64(247); - let __v_11: G = G::from_u64(187); - let __v_12: G = G::from_u64(186); - let __v_13: G = G::from_u64(16); - let __v_14: G = G::from_u64(176); - let __v_15: G = G::from_u64(119); - let __v_16: G = G::from_u64(132); - let __v_17: G = G::from_u64(142); - let __v_18: G = G::from_u64(195); - let __v_19: G = G::from_u64(58); - let __v_20: G = G::from_u64(240); - let __v_21: G = G::from_u64(62); - let __v_22: G = G::from_u64(244); - let __v_23: G = G::from_u64(4); - let __v_24: G = G::from_u64(11); - let __v_25: G = G::from_u64(250); - let __v_26: G = G::from_u64(79); - let __v_27: G = G::from_u64(130); - let __v_28: G = G::from_u64(147); - let __v_29: G = G::from_u64(13); - let __v_30: G = G::from_u64(228); - let __v_31: G = G::from_u64(186); + 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)); __ptr } }; let __ret: [G; OUT_301] = [__v_32]; record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28440,38 +28391,38 @@ fn aiur_fn_302( unconstrained: bool, ) -> Result<[G; OUT_302], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(14); - let __v_1: G = G::from_u64(190); - let __v_2: G = G::from_u64(52); - let __v_3: G = G::from_u64(93); - let __v_4: G = G::from_u64(196); - let __v_5: G = G::from_u64(105); - let __v_6: G = G::from_u64(23); - let __v_7: G = G::from_u64(200); - let __v_8: G = G::from_u64(36); - let __v_9: G = G::from_u64(182); - let __v_10: G = G::from_u64(195); - let __v_11: G = G::from_u64(246); - let __v_12: G = G::from_u64(196); - let __v_13: G = G::from_u64(43); - let __v_14: G = G::from_u64(16); - let __v_15: G = G::from_u64(31); - let __v_16: G = G::from_u64(42); - let __v_17: G = G::from_u64(200); - let __v_18: G = G::from_u64(192); - let __v_19: G = G::from_u64(226); - let __v_20: G = G::from_u64(201); - let __v_21: G = G::from_u64(159); - let __v_22: G = G::from_u64(3); - let __v_23: G = G::from_u64(58); - let __v_24: G = G::from_u64(14); - let __v_25: G = G::from_u64(227); - let __v_26: G = G::from_u64(198); - let __v_27: G = G::from_u64(10); - let __v_28: G = G::from_u64(203); - let __v_29: G = G::from_u64(156); - let __v_30: G = G::from_u64(216); - let __v_31: G = G::from_u64(77); + let __v_0: G = G::from_u64(37); + let __v_1: G = G::from_u64(138); + let __v_2: G = G::from_u64(115); + let __v_3: G = G::from_u64(100); + let __v_4: G = G::from_u64(184); + let __v_5: G = G::from_u64(124); + let __v_6: G = G::from_u64(153); + let __v_7: G = G::from_u64(254); + let __v_8: G = G::from_u64(159); + let __v_9: G = G::from_u64(131); + let __v_10: G = G::from_u64(224); + let __v_11: G = G::from_u64(94); + let __v_12: G = G::from_u64(13); + let __v_13: G = G::from_u64(5); + let __v_14: G = G::from_u64(201); + let __v_15: G = G::from_u64(53); + let __v_16: G = G::from_u64(96); + let __v_17: G = G::from_u64(154); + let __v_18: G = G::from_u64(13); + let __v_19: G = G::from_u64(197); + let __v_20: G = G::from_u64(223); + let __v_21: G = G::from_u64(141); + let __v_22: G = G::from_u64(119); + let __v_23: G = G::from_u64(147); + let __v_24: G = G::from_u64(145); + let __v_25: G = G::from_u64(48); + let __v_26: G = G::from_u64(239); + let __v_27: G = G::from_u64(229); + let __v_28: G = G::from_u64(224); + 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 __ret: [G; OUT_302] = [__v_32]; record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28489,38 +28440,38 @@ fn aiur_fn_303( unconstrained: bool, ) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(247); - let __v_1: G = G::from_u64(152); - let __v_2: G = G::from_u64(66); - let __v_3: G = G::from_u64(241); - let __v_4: G = G::from_u64(2); - let __v_5: G = G::from_u64(6); - let __v_6: G = G::from_u64(89); - let __v_7: G = G::from_u64(137); - let __v_8: G = G::from_u64(41); - let __v_9: G = G::from_u64(230); - let __v_10: G = G::from_u64(186); - let __v_11: G = G::from_u64(96); - let __v_12: G = G::from_u64(206); - let __v_13: G = G::from_u64(62); - let __v_14: G = G::from_u64(186); - let __v_15: G = G::from_u64(160); - let __v_16: G = G::from_u64(13); - let __v_17: G = G::from_u64(17); - let __v_18: G = G::from_u64(242); - let __v_19: G = G::from_u64(1); - let __v_20: G = G::from_u64(201); - let __v_21: G = G::from_u64(158); - let __v_22: G = G::from_u64(128); - let __v_23: G = G::from_u64(40); - let __v_24: G = G::from_u64(95); - let __v_25: G = G::from_u64(70); - let __v_26: G = G::from_u64(204); - let __v_27: G = G::from_u64(14); - let __v_28: G = G::from_u64(144); - let __v_29: G = G::from_u64(147); - let __v_30: G = G::from_u64(40); - let __v_31: G = G::from_u64(50); + let __v_0: G = G::from_u64(119); + let __v_1: G = G::from_u64(213); + let __v_2: G = G::from_u64(25); + let __v_3: G = G::from_u64(37); + let __v_4: G = G::from_u64(158); + let __v_5: G = G::from_u64(201); + let __v_6: G = G::from_u64(250); + let __v_7: G = G::from_u64(72); + let __v_8: G = G::from_u64(157); + let __v_9: G = G::from_u64(190); + let __v_10: G = G::from_u64(14); + let __v_11: G = G::from_u64(61); + let __v_12: G = G::from_u64(192); + let __v_13: G = G::from_u64(185); + let __v_14: G = G::from_u64(53); + let __v_15: G = G::from_u64(42); + let __v_16: G = G::from_u64(239); + let __v_17: G = G::from_u64(52); + let __v_18: G = G::from_u64(156); + let __v_19: G = G::from_u64(205); + let __v_20: G = G::from_u64(170); + let __v_21: G = G::from_u64(115); + let __v_22: G = G::from_u64(234); + let __v_23: G = G::from_u64(88); + let __v_24: G = G::from_u64(176); + let __v_25: G = G::from_u64(139); + let __v_26: G = G::from_u64(176); + let __v_27: G = G::from_u64(188); + let __v_28: G = G::from_u64(104); + 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 __ret: [G; OUT_303] = [__v_32]; record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28538,38 +28489,38 @@ fn aiur_fn_304( unconstrained: bool, ) -> Result<[G; OUT_304], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(66); - let __v_1: G = G::from_u64(13); - let __v_2: G = G::from_u64(234); - let __v_3: G = G::from_u64(210); - let __v_4: G = G::from_u64(22); - let __v_5: G = G::from_u64(138); - let __v_6: G = G::from_u64(189); - let __v_7: G = G::from_u64(22); - let __v_8: G = G::from_u64(167); - let __v_9: G = G::from_u64(5); - let __v_10: G = G::from_u64(14); - let __v_11: G = G::from_u64(223); - let __v_12: G = G::from_u64(216); - let __v_13: G = G::from_u64(225); - let __v_14: G = G::from_u64(125); - let __v_15: G = G::from_u64(69); - let __v_16: G = G::from_u64(21); - let __v_17: G = G::from_u64(82); - let __v_18: G = G::from_u64(55); - let __v_19: G = G::from_u64(211); - let __v_20: G = G::from_u64(17); - let __v_21: G = G::from_u64(135); - let __v_22: G = G::from_u64(130); - let __v_23: G = G::from_u64(208); - let __v_24: G = G::from_u64(230); - let __v_25: G = G::from_u64(139); - let __v_26: G = G::from_u64(109); - let __v_27: G = G::from_u64(232); - let __v_28: G = G::from_u64(119); - let __v_29: G = G::from_u64(66); - let __v_30: G = G::from_u64(203); - let __v_31: G = G::from_u64(141); + let __v_0: G = G::from_u64(162); + let __v_1: G = G::from_u64(154); + let __v_2: G = G::from_u64(99); + let __v_3: G = G::from_u64(97); + let __v_4: G = G::from_u64(118); + let __v_5: G = G::from_u64(207); + let __v_6: G = G::from_u64(17); + let __v_7: G = G::from_u64(53); + let __v_8: G = G::from_u64(208); + let __v_9: G = G::from_u64(119); + let __v_10: G = G::from_u64(235); + let __v_11: G = G::from_u64(7); + let __v_12: G = G::from_u64(71); + let __v_13: G = G::from_u64(152); + let __v_14: G = G::from_u64(249); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(124); + let __v_17: G = G::from_u64(120); + let __v_18: G = G::from_u64(231); + let __v_19: G = G::from_u64(128); + let __v_20: G = G::from_u64(19); + let __v_21: G = G::from_u64(131); + let __v_22: G = G::from_u64(233); + let __v_23: G = G::from_u64(207); + let __v_24: G = G::from_u64(243); + let __v_25: G = G::from_u64(99); + let __v_26: G = G::from_u64(186); + let __v_27: G = G::from_u64(229); + let __v_28: G = G::from_u64(237); + 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 __ret: [G; OUT_304] = [__v_32]; record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28587,38 +28538,38 @@ fn aiur_fn_305( unconstrained: bool, ) -> Result<[G; OUT_305], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(193); - let __v_1: G = G::from_u64(39); - let __v_2: G = G::from_u64(248); - let __v_3: G = G::from_u64(159); - let __v_4: G = G::from_u64(146); - let __v_5: G = G::from_u64(224); - let __v_6: G = G::from_u64(72); - let __v_7: G = G::from_u64(31); - let __v_8: G = G::from_u64(122); - let __v_9: G = G::from_u64(62); - let __v_10: G = G::from_u64(6); - let __v_11: G = G::from_u64(49); - let __v_12: G = G::from_u64(197); - let __v_13: G = G::from_u64(97); - let __v_14: G = G::from_u64(95); - let __v_15: G = G::from_u64(231); - let __v_16: G = G::from_u64(246); - let __v_17: G = G::from_u64(203); - let __v_18: G = G::from_u64(191); - let __v_19: G = G::from_u64(67); - let __v_20: G = G::from_u64(157); - let __v_21: G = G::from_u64(95); - let __v_22: G = G::from_u64(215); - let __v_23: G = G::from_u64(235); - let __v_24: G = G::from_u64(164); - let __v_25: G = G::from_u64(0); - let __v_26: G = G::from_u64(251); - let __v_27: G = G::from_u64(6); - let __v_28: G = G::from_u64(3); - let __v_29: G = G::from_u64(174); - let __v_30: G = G::from_u64(223); - let __v_31: G = G::from_u64(47); + let __v_0: G = G::from_u64(221); + let __v_1: G = G::from_u64(161); + let __v_2: G = G::from_u64(43); + let __v_3: G = G::from_u64(203); + let __v_4: G = G::from_u64(51); + let __v_5: G = G::from_u64(7); + let __v_6: G = G::from_u64(39); + let __v_7: G = G::from_u64(246); + let __v_8: G = G::from_u64(223); + let __v_9: G = G::from_u64(184); + let __v_10: G = G::from_u64(22); + let __v_11: G = G::from_u64(188); + let __v_12: G = G::from_u64(151); + let __v_13: G = G::from_u64(82); + let __v_14: G = G::from_u64(170); + let __v_15: G = G::from_u64(189); + let __v_16: G = G::from_u64(5); + let __v_17: G = G::from_u64(32); + let __v_18: G = G::from_u64(230); + let __v_19: G = G::from_u64(81); + let __v_20: G = G::from_u64(91); + let __v_21: G = G::from_u64(121); + let __v_22: G = G::from_u64(252); + let __v_23: G = G::from_u64(138); + let __v_24: G = G::from_u64(90); + let __v_25: G = G::from_u64(158); + let __v_26: G = G::from_u64(113); + let __v_27: G = G::from_u64(56); + let __v_28: G = G::from_u64(102); + 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 __ret: [G; OUT_305] = [__v_32]; record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -29993,7 +29944,7 @@ fn aiur_fn_320( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_29]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -30049,7 +30000,7 @@ fn aiur_fn_320( 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_744] = { let __args: [G; IN_744] = [__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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__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[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_70: G = __r_arr[0]; @@ -31021,7 +30972,7 @@ fn aiur_fn_339( } }, 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -31092,7 +31043,7 @@ fn aiur_fn_340( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __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_729] = { let __args: [G; IN_729] = [__v_2, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; 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_8: G = __r_arr[0]; @@ -31444,7 +31395,7 @@ fn aiur_fn_343( }, 0u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_12]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0]; @@ -31454,7 +31405,7 @@ fn aiur_fn_343( match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_16]; 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)? } }; @@ -31502,7 +31453,7 @@ fn aiur_fn_343( }, 0u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_12]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_12]; 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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_2, __v_3, __v_4]; 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_14: G = __r_arr[0]; @@ -31512,7 +31463,7 @@ fn aiur_fn_343( match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_16]; 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)? } }; @@ -31593,12 +31544,12 @@ fn aiur_fn_344( }, 0u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_8]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_8]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_3, __v_4, __v_5]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_11]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_12, __v_3, __v_4, __v_5]; 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_13: G = __r_arr[0]; @@ -31618,7 +31569,7 @@ fn aiur_fn_344( match __v_18.as_canonical_u64() { 1u64 => { let __v_20: G = G::from_u64(2); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_19, __v_21]; 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)? } }; @@ -32184,10 +32135,10 @@ fn aiur_fn_348( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_9]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0]; @@ -32309,7 +32260,7 @@ fn aiur_fn_349( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_8: G = __r_arr[0]; let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -32325,10 +32276,10 @@ fn aiur_fn_349( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_15]; 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_729] = { let __args: [G; IN_729] = [__v_3, __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_726] = { let __args: [G; IN_726] = [__v_3, __v_17]; 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_729] = { let __args: [G; IN_729] = [__v_3, __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 __ret: [G; OUT_349] = [__v_14, __v_16, __v_18]; record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -32423,7 +32374,7 @@ fn aiur_fn_349( }, 0u64 => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_48]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_48]; 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_49: G = __r_arr[0]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; @@ -32435,7 +32386,7 @@ fn aiur_fn_349( let __v_55: G = __loaded[3]; match __v_52.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_53]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_53]; 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_56: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; @@ -32465,10 +32416,10 @@ fn aiur_fn_349( 0u64 => { let __v_62: G = G::from_u64(1); let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_51, __v_63]; 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_729] = { let __args: [G; IN_729] = [__v_51, __v_63]; 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_64: G = __r_arr[0]; let __v_65: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_65]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_65]; 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_66: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_62, __v_64, __v_66]; record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -32575,13 +32526,13 @@ fn aiur_fn_350( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_9]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(2); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_11]; 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_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 __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_8, __v_10, __v_1, __v_2, __v_3]; 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_13: G = __r_arr[0]; @@ -32834,7 +32785,7 @@ fn aiur_fn_353( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_8: G = __r_arr[0]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -32846,7 +32797,7 @@ fn aiur_fn_353( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_12]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_12]; 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 __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; 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_16: G = __r_arr[0]; @@ -32881,7 +32832,7 @@ fn aiur_fn_353( }, 0u64 => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_21]; 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_729] = { let __args: [G; IN_729] = [__v_10, __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_22: G = __r_arr[0]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; @@ -32893,7 +32844,7 @@ fn aiur_fn_353( let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_26]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_26]; 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_29: G = __r_arr[0]; let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; @@ -32928,13 +32879,13 @@ fn aiur_fn_353( }, 0u64 => { let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_24, __v_35]; 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_729] = { let __args: [G; IN_729] = [__v_24, __v_35]; 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_36: G = __r_arr[0]; let __v_37: G = G::from_u64(2); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_37]; 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_729] = { let __args: [G; IN_729] = [__v_10, __v_37]; 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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(3); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_39]; 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_729] = { let __args: [G; IN_729] = [__v_10, __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 __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); @@ -33112,7 +33063,7 @@ fn aiur_fn_354( }, 0u64 => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_21]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_22: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_22, __v_2, __v_3, __v_4]; 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_23: G = __r_arr[0]; @@ -33262,7 +33213,7 @@ fn aiur_fn_357( }, 0u64 => { let __v_5: G = G::from_u64(2); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_5]; 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_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 __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -33274,7 +33225,7 @@ fn aiur_fn_357( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_10]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_10]; 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 __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; 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_14: G = __r_arr[0]; @@ -33352,7 +33303,7 @@ fn aiur_fn_358( }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_5]; 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_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 __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -33364,7 +33315,7 @@ fn aiur_fn_358( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_10]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_10]; 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 __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -33434,7 +33385,7 @@ fn aiur_fn_359( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; 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]; @@ -33656,7 +33607,7 @@ fn aiur_fn_362( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; 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)? } }; let __v_11: G = __r_arr[0]; @@ -33844,10 +33795,10 @@ fn aiur_fn_364( }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_9]; 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_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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_11]; 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_729] = { let __args: [G; IN_729] = [__v_2, __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 __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_10, __v_5]; 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_13: G = __r_arr[0]; @@ -33951,7 +33902,7 @@ fn aiur_fn_365( let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_25, __v_19, __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 = G::from_u64(2); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_2, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_2, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_28, __v_30]; 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)? } }; @@ -34032,10 +33983,10 @@ fn aiur_fn_366( match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_9]; 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_729] = { let __args: [G; IN_729] = [__v_5, __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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_11]; 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_729] = { let __args: [G; IN_729] = [__v_5, __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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_6, __v_7, __v_8]; 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_13: G = __r_arr[0]; @@ -34096,7 +34047,7 @@ fn aiur_fn_366( let __v_39: G = G::from_u64(0); let __v_40: G = { let __values: [G; 4] = [__v_38, __v_37, __v_12, __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(2); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_40, __v_42]; 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_43: G = __r_arr[0]; @@ -34149,10 +34100,10 @@ fn aiur_fn_367( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_8]; 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_729] = { let __args: [G; IN_729] = [__v_4, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_10]; 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_729] = { let __args: [G; IN_729] = [__v_4, __v_10]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5, __v_6, __v_7]; 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_12: G = __r_arr[0]; @@ -34527,7 +34478,7 @@ fn aiur_fn_369( let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_12, __v_2, __v_3, __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(2); - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_14, __v_16]; 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_17: G = __r_arr[0]; @@ -34555,7 +34506,7 @@ fn aiur_fn_369( }, 0u64 => { let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_21, __v_25]; 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_729] = { let __args: [G; IN_729] = [__v_21, __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(2); let __v_28: G = G::from_u64(1); @@ -34570,7 +34521,7 @@ fn aiur_fn_369( let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 4] = [__v_36, __v_35, __v_1, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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(2); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_38, __v_40]; 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)? } }; @@ -34621,7 +34572,7 @@ fn aiur_fn_370( }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_6]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_6]; 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_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]; @@ -34638,7 +34589,7 @@ fn aiur_fn_370( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - 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_723] = { let __args: [G; IN_723] = [__v_10]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -35479,7 +35430,7 @@ fn aiur_fn_381( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __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_729] = { let __args: [G; IN_729] = [__v_2, __v_0]; 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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -35519,11 +35470,11 @@ fn aiur_fn_381( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_20]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_20]; 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(8); let __v_25: G = { let __values: [G; 4] = [__v_24, __v_18, __v_19, __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_741] = { let __args: [G; IN_741] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_25, __v_26]; 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)? } }; @@ -35578,7 +35529,7 @@ fn aiur_fn_382( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __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_729] = { let __args: [G; IN_729] = [__v_4, __v_0]; 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_5: G = __r_arr[0]; let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; 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_6: G = __r_arr[0]; @@ -35605,7 +35556,7 @@ fn aiur_fn_382( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_9]; 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_729] = { let __args: [G; IN_729] = [__v_4, __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_12: G = __r_arr[0]; let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; @@ -35640,19 +35591,19 @@ fn aiur_fn_382( }, 0u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_18]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_20]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_20]; 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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_22]; 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_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]; let __v_24: G = G::from_u64(3); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_24]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_24]; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(4); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_26]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_26]; 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_27: 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_28: G = __loaded[0]; @@ -35721,7 +35672,7 @@ fn aiur_fn_382( let __v_79: G = G::from_u64(0); let __v_80: G = { let __values: [G; 4] = [__v_78, __v_77, __v_27, __v_79]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(5); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_3, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_3, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = G::from_u64(1); let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_80, __v_82]; 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)? } }; @@ -36219,7 +36170,7 @@ fn aiur_fn_391( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_2]; 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_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_7: G = __r_arr[0]; let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__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]; @@ -36275,7 +36226,7 @@ fn aiur_fn_392( 1u64 => { let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_1]; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_392] = [__v_5]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36724,7 +36675,7 @@ fn aiur_fn_398( match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_8, __v_2, __v_9]; 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)? } }; @@ -37003,7 +36954,7 @@ fn aiur_fn_402( }, 1u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_9, __v_12]; 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_729] = { let __args: [G; IN_729] = [__v_9, __v_12]; 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(0); let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_13, __v_14]; 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)? } }; @@ -37053,7 +37004,7 @@ fn aiur_fn_403( let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10, __v_1]; 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_724] = { let __args: [G; IN_724] = [__v_10, __v_1]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0]; @@ -37144,7 +37095,7 @@ fn aiur_fn_404( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_13]; 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_729] = { let __args: [G; IN_729] = [__v_5, __v_13]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -37220,7 +37171,7 @@ fn aiur_fn_405( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_6]; 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_729] = { let __args: [G; IN_729] = [__v_4, __v_6]; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -37253,12 +37204,12 @@ fn aiur_fn_405( match __v_18.as_canonical_u64() { 2u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_19]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_19]; 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_20: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_2, __v_3, __v_4]; 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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_22]; 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_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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_2, __v_3, __v_4]; 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_24: G = __r_arr[0]; @@ -37490,9 +37441,9 @@ fn aiur_fn_407( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_6, __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_729] = { let __args: [G; IN_729] = [__v_6, __v_0]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __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_729] = { let __args: [G; IN_729] = [__v_5, __v_0]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -37763,7 +37714,7 @@ fn aiur_fn_410( let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10, __v_1]; 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_724] = { let __args: [G; IN_724] = [__v_10, __v_1]; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_9, __v_11, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0]; @@ -37847,7 +37798,7 @@ fn aiur_fn_411( }, 1u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_9, __v_12]; 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_729] = { let __args: [G; IN_729] = [__v_9, __v_12]; 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(0); let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_13, __v_14]; 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)? } }; @@ -37913,7 +37864,7 @@ fn aiur_fn_412( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_13]; 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_729] = { let __args: [G; IN_729] = [__v_5, __v_13]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -37984,9 +37935,9 @@ fn aiur_fn_413( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_6, __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_729] = { let __args: [G; IN_729] = [__v_6, __v_0]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __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_729] = { let __args: [G; IN_729] = [__v_5, __v_0]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38368,7 +38319,7 @@ fn aiur_fn_418( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __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_729] = { let __args: [G; IN_729] = [__v_2, __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_7: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -38392,10 +38343,10 @@ fn aiur_fn_418( match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_13]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_15]; 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_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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -38614,7 +38565,7 @@ fn aiur_fn_420( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_13: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 1u64 => { @@ -38662,7 +38613,7 @@ fn aiur_fn_420( let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_9, __v_23]; 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_729] = { let __args: [G; IN_729] = [__v_9, __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_26: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -38678,7 +38629,7 @@ fn aiur_fn_420( let __v_37: G = __loaded[10]; match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_38.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_39.as_canonical_u64() { @@ -38708,7 +38659,7 @@ fn aiur_fn_420( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_6, __v_31]; 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_740] = { let __args: [G; IN_740] = [__v_6, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; @@ -38716,14 +38667,14 @@ fn aiur_fn_420( _ => { let __v_45: G = (__v_3 + __v_4); let __v_46: G = (__v_2 + __v_45); - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = (__v_40 - __v_33); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_21, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_21, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_5 + __v_50); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_44, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; @@ -38809,7 +38760,7 @@ fn aiur_fn_421( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __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_729] = { let __args: [G; IN_729] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_5, __v_6, __v_7]; 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_11: G = __r_arr[0]; @@ -38831,7 +38782,7 @@ fn aiur_fn_421( let __v_14: G = (__v_1 + __v_2); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 + __v_15); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_16]; 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_729] = { let __args: [G; IN_729] = [__v_0, __v_16]; 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 __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_17, __v_5, __v_6, __v_7]; 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_18: G = __r_arr[0]; @@ -38849,13 +38800,13 @@ fn aiur_fn_421( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_14]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_20: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_5, __v_6, __v_7]; 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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_4 + __v_22); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_21, __v_7]; 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_25: G = __r_arr[0]; @@ -38993,7 +38944,7 @@ fn aiur_fn_422( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_13]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_13]; 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 __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; 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_17: G = __r_arr[0]; @@ -39014,7 +38965,7 @@ fn aiur_fn_422( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_11, __v_22]; 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_729] = { let __args: [G; IN_729] = [__v_11, __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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -39095,18 +39046,18 @@ fn aiur_fn_423( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_5, __v_11]; 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_740] = { let __args: [G; IN_740] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_8, __v_12]; 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_729] = { let __args: [G; IN_729] = [__v_8, __v_12]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -39122,7 +39073,7 @@ fn aiur_fn_423( let __v_26: G = __loaded[10]; match __v_16.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_8, __v_19]; 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_729] = { let __args: [G; IN_729] = [__v_8, __v_19]; 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_27: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; @@ -39144,60 +39095,62 @@ fn aiur_fn_423( 1u64 => { match __v_32.as_canonical_u64() { 0u64 => { - match __v_34.as_canonical_u64() { + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_19, __v_8]; 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_40: G = __r_arr[0]; + match __v_40.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __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_40: G = __r_arr[0]; - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_40, __v_7, __v_8, __v_9]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_41: G = __r_arr[0]; - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_41, __v_7, __v_8, __v_9]; 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_434] = { let __args: [G; IN_434] = [__v_41, __v_7, __v_8, __v_9]; 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_42: G = __r_arr[0]; - match __v_42.as_canonical_u64() { + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_42, __v_7, __v_8, __v_9]; 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_43: G = __r_arr[0]; + match __v_43.as_canonical_u64() { 1u64 => { - let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __v_47: G = { 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_423] = [__v_43, __v_47]; + let __v_47: G = G::from_u64(0); + let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_423] = [__v_44, __v_48]; record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; - let __v_43: G = __r_arr[0]; - let __v_44: G = (__v_1 + __v_2); - let __v_45: G = (__v_44 + __v_3); - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_43, __v_46]; 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_44: G = __r_arr[0]; + let __v_45: G = (__v_1 + __v_2); + let __v_46: G = (__v_45 + __v_3); + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; - let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_47, __v_19, __v_40, __v_13, __v_48]; 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_49: G = __r_arr[0]; - let __v_50: G = G::from_u64(1); - let __v_51: G = (__v_4 + __v_50); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_49, __v_52]; 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_400] = { let __args: [G; IN_400] = [__v_44, __v_47]; 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_48: G = __r_arr[0]; + let __v_49: G = G::from_u64(0); + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_48, __v_19, __v_41, __v_13, __v_49]; 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_50: G = __r_arr[0]; + let __v_51: G = G::from_u64(1); + let __v_52: G = (__v_4 + __v_51); + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __v_54: G = G::from_u64(1); - let __ret: [G; OUT_423] = [__v_54, __v_53]; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_50, __v_53]; 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_54: G = __r_arr[0]; + let __v_55: G = G::from_u64(1); + let __ret: [G; OUT_423] = [__v_55, __v_54]; record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64())); }, } }, _ => { - let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); - let __v_44: G = { 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_423] = [__v_40, __v_44]; + let __v_44: G = G::from_u64(0); + let __v_45: G = { let __values: [G; 4] = [__v_42, __v_43, __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 __ret: [G; OUT_423] = [__v_41, __v_45]; record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, @@ -39330,10 +39283,10 @@ fn aiur_fn_425( }, 0u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_9]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_10, __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_11: G = __r_arr[0]; @@ -39341,7 +39294,7 @@ fn aiur_fn_425( match __v_11.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(0); @@ -39406,10 +39359,10 @@ fn aiur_fn_426( }, 0u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(4); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_9]; 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_729] = { let __args: [G; IN_729] = [__v_0, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_10, __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_11: G = __r_arr[0]; @@ -39417,7 +39370,7 @@ fn aiur_fn_426( match __v_11.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(0); @@ -39477,7 +39430,7 @@ fn aiur_fn_427( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_8]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_8]; 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_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -39502,7 +39455,7 @@ fn aiur_fn_427( match __v_25.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(2); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_6, __v_26]; 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_729] = { let __args: [G; IN_729] = [__v_6, __v_26]; 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_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __ret: [G; OUT_427] = [__v_28, __v_27]; @@ -39635,7 +39588,7 @@ fn aiur_fn_429( 0u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_4, __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_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -39651,7 +39604,7 @@ fn aiur_fn_429( let __v_22: G = __loaded[10]; match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_15]; 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_729] = { let __args: [G; IN_729] = [__v_4, __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_23: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -39682,7 +39635,7 @@ fn aiur_fn_429( }, _ => { let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_29, __v_36]; 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_729] = { let __args: [G; IN_729] = [__v_29, __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 __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_3, __v_4, __v_5]; 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_38: G = __r_arr[0]; @@ -39704,7 +39657,7 @@ fn aiur_fn_429( let __v_47: G = G::from_u64(2); let __v_48: G = G::from_u64(0); let __v_49: G = { let __values: [G; 4] = [__v_47, __v_37, __v_44, __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 __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_49, __v_50]; 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_51: G = __r_arr[0]; @@ -40033,7 +39986,7 @@ fn aiur_fn_435( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_2, __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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -40159,7 +40112,7 @@ fn aiur_fn_435( if (__v_13 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); } - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_13]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_13]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -40185,9 +40138,9 @@ fn aiur_fn_435( let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_19, __v_14, __v_30, __v_1, __v_2, __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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_22, __v_32]; 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_729] = { let __args: [G; IN_729] = [__v_22, __v_32]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_33]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_33]; 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_34: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; @@ -40461,7 +40414,7 @@ fn aiur_fn_440( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_2, __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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -40604,7 +40557,7 @@ fn aiur_fn_440( if (__v_13 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); } - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_13]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_13]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -40630,9 +40583,9 @@ fn aiur_fn_440( let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_19, __v_14, __v_30, __v_1, __v_2, __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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_22, __v_32]; 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_729] = { let __args: [G; IN_729] = [__v_22, __v_32]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_33]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_33]; 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_34: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; @@ -41815,7 +41768,7 @@ fn aiur_fn_459( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -41831,51 +41784,35 @@ fn aiur_fn_459( let __v_19: G = __loaded[10]; match __v_9.as_canonical_u64() { 5u64 => { - match __v_15.as_canonical_u64() { + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + match __v_20.as_canonical_u64() { 1u64 => { - let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_20]; - record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - 0u64 => { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - match __v_20.as_canonical_u64() { - 1u64 => { - let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_14, __v_21]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_22]; 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_23: G = __r_arr[0]; - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; - let __v_24: G = __loaded[0]; - let __v_25: G = __loaded[1]; - let __v_26: G = __loaded[2]; - let __v_27: G = __loaded[3]; - let __v_28: G = __loaded[4]; - let __v_29: G = __loaded[5]; - let __v_30: G = __loaded[6]; - let __v_31: G = __loaded[7]; - let __v_32: G = __loaded[8]; - let __v_33: G = __loaded[9]; - let __v_34: G = __loaded[10]; - match __v_24.as_canonical_u64() { - 6u64 => { - match __v_30.as_canonical_u64() { - 0u64 => { - let __v_35: G = G::from_u64(1); - let __ret: [G; OUT_459] = [__v_35]; - record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - let __v_35: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_35]; - record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_14, __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_22: G = __r_arr[0]; + 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + let __v_28: G = __loaded[4]; + let __v_29: G = __loaded[5]; + let __v_30: G = __loaded[6]; + let __v_31: G = __loaded[7]; + let __v_32: G = __loaded[8]; + let __v_33: G = __loaded[9]; + let __v_34: G = __loaded[10]; + match __v_24.as_canonical_u64() { + 6u64 => { + match __v_30.as_canonical_u64() { + 0u64 => { + let __v_35: G = G::from_u64(1); + let __ret: [G; OUT_459] = [__v_35]; + record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); }, _ => { let __v_35: G = G::from_u64(0); @@ -41886,15 +41823,18 @@ fn aiur_fn_459( } }, _ => { - let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_21]; + let __v_35: G = G::from_u64(0); + let __ret: [G; OUT_459] = [__v_35]; record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + let __v_21: G = G::from_u64(0); + let __ret: [G; OUT_459] = [__v_21]; + record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); }, } }, @@ -42054,7 +41994,7 @@ fn aiur_fn_462( } }, 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_6: G = __r_arr[0]; let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -42124,7 +42064,7 @@ fn aiur_fn_463( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_10: G = __r_arr[0]; let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; 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]; @@ -42165,7 +42105,7 @@ fn aiur_fn_463( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_11]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_14: G = __r_arr[0]; let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; @@ -42381,7 +42321,7 @@ fn aiur_fn_465( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_8]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_8]; 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_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -42403,7 +42343,7 @@ fn aiur_fn_465( let __v_25: G = (__v_23 - __v_24); match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_15]; 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_729] = { let __args: [G; IN_729] = [__v_3, __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_26: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -42419,32 +42359,45 @@ fn aiur_fn_465( let __v_37: G = __loaded[10]; match __v_27.as_canonical_u64() { 5u64 => { - let __v_38: G = G::from_bool((__v_33 == G::ZERO)); - let __v_39: G = G::from_bool((__v_31 == G::ZERO)); + let __v_38: G = G::from_bool((__v_31 == G::ZERO)); let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; - let __v_40: G = __r_arr[0]; - let __v_41: G = G::from_u64(1); - let __v_42: G = (__v_40 - __v_41); - let __v_43: G = G::from_bool((__v_42 == G::ZERO)); - let __v_44: G = (__v_39 * __v_43); - let __v_45: G = (__v_38 * __v_44); - match __v_45.as_canonical_u64() { + let __v_39: G = __r_arr[0]; + let __v_40: G = G::from_u64(1); + let __v_41: G = (__v_39 - __v_40); + let __v_42: G = G::from_bool((__v_41 == G::ZERO)); + let __v_43: G = (__v_38 * __v_42); + match __v_43.as_canonical_u64() { 0u64 => { - let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_465] = [__v_46]; + let __v_44: G = G::from_u64(0); + let __ret: [G; OUT_465] = [__v_44]; record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_15, __v_17, __v_18, __v_0, __v_6, __v_46, __v_2, __v_3, __v_4]; 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_47: G = __r_arr[0]; - let __ret: [G; OUT_465] = [__v_47]; - record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_15, __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_44: G = __r_arr[0]; + match __v_44.as_canonical_u64() { + 1u64 => { + let __v_45: G = G::from_u64(0); + let __ret: [G; OUT_465] = [__v_45]; + record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_45: G = G::from_u64(0); + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_15, __v_17, __v_18, __v_0, __v_6, __v_45, __v_2, __v_3, __v_4]; 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_46: G = __r_arr[0]; + let __ret: [G; OUT_465] = [__v_46]; + record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); + }, + } }, _ => { - return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64())); }, } }, @@ -42513,7 +42466,7 @@ fn aiur_fn_466( let __v_10: G = G::from_u64(8); let __v_11: G = { let __values: [G; 4] = [__v_10, __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_12: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_12]; 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_729] = { let __args: [G; IN_729] = [__v_4, __v_12]; 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 __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_11, __v_13, __v_6, __v_7, __v_8]; 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_14: G = __r_arr[0]; @@ -43263,7 +43216,7 @@ fn aiur_fn_472( 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_726] = { let __args: [G; IN_726] = [__v_1, __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_729] = { let __args: [G; IN_729] = [__v_1, __v_0]; 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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -43312,7 +43265,7 @@ fn aiur_fn_473( 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_726] = { let __args: [G; IN_726] = [__v_1, __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_729] = { let __args: [G; IN_729] = [__v_1, __v_0]; 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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -43364,7 +43317,7 @@ fn aiur_fn_474( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -44503,7 +44456,7 @@ fn aiur_fn_492( let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_1, __v_3]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_2, __v_4]; 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_2, __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_8: G = __r_arr[0]; let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_6, __v_8, __v_7, __v_4, __v_5]; 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 __ret: [G; OUT_492] = []; @@ -44660,7 +44613,7 @@ fn aiur_fn_496( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_1]; 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_0, __v_1]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { @@ -44678,7 +44631,7 @@ fn aiur_fn_496( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_8, __v_1]; 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_8, __v_1]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { @@ -44711,7 +44664,7 @@ fn aiur_fn_496( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_14]; 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_729] = { let __args: [G; IN_729] = [__v_3, __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_18: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; @@ -44727,17 +44680,17 @@ fn aiur_fn_496( let __v_29: G = __loaded[10]; match __v_19.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_12, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_12, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_30, __v_1]; 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_30, __v_1]; 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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64() }); } - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1, __v_29, __v_3]; 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_1, __v_26, __v_3]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_24, __v_12, __v_33, __v_3, __v_4]; 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_24, __v_12, __v_33, __v_3, __v_4]; 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 __ret: [G; OUT_496] = []; record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -44825,8 +44778,8 @@ fn aiur_fn_497( }) } -const INPUT_SIZE_498: usize = 4; -const IN_498: usize = 4; +const INPUT_SIZE_498: usize = 2; +const IN_498: usize = 2; const OUT_498: usize = 1; fn aiur_fn_498( inp: [G; IN_498], @@ -44834,6 +44787,52 @@ fn aiur_fn_498( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_498], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1, __v_0]; 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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __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_14: G = __r_arr[0]; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_8, __v_6, __v_14, __v_1]; 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_15: G = __r_arr[0]; + let __ret: [G; OUT_498] = [__v_15]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_498] = [__v_14]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_499: usize = 4; +const IN_499: usize = 4; +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_499], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44846,12 +44845,12 @@ fn aiur_fn_498( match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_498] = [__v_7]; - record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_499] = [__v_7]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_3, __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_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -44869,20 +44868,20 @@ fn aiur_fn_498( 6u64 => { let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_10, __v_1]; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_19, __v_2]; 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_19, __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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __ret: [G; OUT_498] = [__v_21]; - record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_499] = [__v_21]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_6, __v_1, __v_2, __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_6, __v_1, __v_2, __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_21: G = __r_arr[0]; - let __ret: [G; OUT_498] = [__v_21]; - record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_499] = [__v_21]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44891,10 +44890,10 @@ fn aiur_fn_498( } }, _ => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_6, __v_1, __v_2, __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_6, __v_1, __v_2, __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_19: G = __r_arr[0]; - let __ret: [G; OUT_498] = [__v_19]; - record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_499] = [__v_19]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -44906,15 +44905,15 @@ fn aiur_fn_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], +const INPUT_SIZE_500: usize = 2; +const IN_500: usize = 2; +const OUT_500: usize = 1; +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]; @@ -44925,20 +44924,20 @@ fn aiur_fn_499( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_1]; 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_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_499] = [__v_7]; - record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_7]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_1]; 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_4, __v_1]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_499] = [__v_7]; - record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_7]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -44948,23 +44947,23 @@ fn aiur_fn_499( }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_499] = [__v_6]; - record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_500] = [__v_6]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_500: usize = 2; -const IN_500: usize = 2; -const OUT_500: usize = 1; -fn aiur_fn_500( - inp: [G; IN_500], +const INPUT_SIZE_501: usize = 2; +const IN_501: usize = 2; +const OUT_501: usize = 1; +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]; @@ -44976,38 +44975,38 @@ fn aiur_fn_500( match __v_2.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_500] = [__v_6]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_500] = [__v_6]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_1, __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_6: G = __r_arr[0]; - let __ret: [G; OUT_500] = [__v_6]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_1]; 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_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_500] = [__v_7]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_1]; 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_1]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_500] = [__v_7]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45016,20 +45015,20 @@ fn aiur_fn_500( } }, 4u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_1]; 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_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_500] = [__v_7]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_1]; 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_1]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_500] = [__v_7]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45038,20 +45037,20 @@ fn aiur_fn_500( } }, 5u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_1]; 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_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_500] = [__v_7]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_1]; 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_1]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_500] = [__v_7]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45060,30 +45059,30 @@ fn aiur_fn_500( } }, 6u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_1]; 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_3, __v_1]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_500] = [__v_7]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_1]; 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_1]; 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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_500] = [__v_8]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_8]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_5, __v_1]; 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_5, __v_1]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_500] = [__v_8]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_8]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45098,15 +45097,15 @@ fn aiur_fn_500( }, 7u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_500] = [__v_6]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_5, __v_1]; 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_5, __v_1]; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_500] = [__v_6]; - record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45116,15 +45115,15 @@ fn aiur_fn_500( }) } -const INPUT_SIZE_501: usize = 2; -const IN_501: usize = 2; -const OUT_501: usize = 1; -fn aiur_fn_501( - inp: [G; IN_501], +const INPUT_SIZE_502: usize = 2; +const IN_502: usize = 2; +const OUT_502: usize = 1; +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]; @@ -45135,25 +45134,25 @@ fn aiur_fn_501( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_501] = [__v_5]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_502] = [__v_5]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_1]; 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_3, __v_1]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_501] = [__v_6]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_502] = [__v_6]; + record.function_queries[502].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_1]; 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_1]; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_501] = [__v_6]; - record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_502] = [__v_6]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45168,37 +45167,37 @@ fn aiur_fn_501( }) } -const INPUT_SIZE_502: usize = 3; -const IN_502: usize = 3; -const OUT_502: usize = 1; -fn aiur_fn_502( - inp: [G; IN_502], +const INPUT_SIZE_503: usize = 3; +const IN_503: usize = 3; +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_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]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_2, __v_3]; 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]; 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_4: G = __r_arr[0]; - let __ret: [G; OUT_502] = [__v_4]; - record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_503] = [__v_4]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_503: usize = 4; -const IN_503: usize = 4; -const OUT_503: usize = 1; -fn aiur_fn_503( - inp: [G; IN_503], +const INPUT_SIZE_504: usize = 4; +const IN_504: usize = 4; +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]; @@ -45210,8 +45209,8 @@ fn aiur_fn_503( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_503] = [__v_0]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_0]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -45229,7 +45228,7 @@ fn aiur_fn_503( let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_17, __v_1]; 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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_14, __v_1]; 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_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); @@ -45280,19 +45279,19 @@ fn aiur_fn_503( let __v_61: G = { let __values: [G; 3] = [__v_60, __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_62: G = G::from_u64(1); let __v_63: G = (__v_3 + __v_62); - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_61, __v_1, __v_6, __v_63]; 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_61, __v_1, __v_6, __v_63]; 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_64: G = __r_arr[0]; - let __ret: [G; OUT_503] = [__v_64]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_64]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_60: G = G::from_u64(1); let __v_61: G = (__v_3 + __v_60); - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_6, __v_61]; 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_6, __v_61]; 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_62: G = __r_arr[0]; - let __ret: [G; OUT_503] = [__v_62]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_62]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45303,10 +45302,10 @@ fn aiur_fn_503( _ => { let __v_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_6, __v_19]; 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_6, __v_19]; 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_20: G = __r_arr[0]; - let __ret: [G; OUT_503] = [__v_20]; - record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_504] = [__v_20]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45318,15 +45317,15 @@ fn aiur_fn_503( }) } -const INPUT_SIZE_504: usize = 5; -const IN_504: usize = 5; -const OUT_504: usize = 0; -fn aiur_fn_504( - inp: [G; IN_504], +const INPUT_SIZE_505: usize = 5; +const IN_505: usize = 5; +const OUT_505: usize = 0; +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]; @@ -45339,12 +45338,12 @@ fn aiur_fn_504( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_504] = []; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_505] = []; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_6]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -45367,15 +45366,15 @@ fn aiur_fn_504( let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_23, __v_2, __v_24, __v_3, __v_4]; 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_504] = { let __args: [G; IN_504] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_504] = []; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_505] = []; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_504] = []; - record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_505] = []; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45387,15 +45386,15 @@ fn aiur_fn_504( }) } -const INPUT_SIZE_505: usize = 2; -const IN_505: usize = 2; -const OUT_505: usize = 1; -fn aiur_fn_505( - inp: [G; IN_505], +const INPUT_SIZE_506: usize = 2; +const IN_506: usize = 2; +const OUT_506: usize = 1; +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]; @@ -45407,14 +45406,14 @@ fn aiur_fn_505( match __v_2.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_505] = [__v_6]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_505] = [__v_6]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { @@ -45422,77 +45421,77 @@ fn aiur_fn_505( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_505] = [__v_7]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_7]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_505] = [__v_7]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_7]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_3, __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_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_4, __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_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_505] = [__v_8]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_8]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_3, __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_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_4, __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_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_505] = [__v_8]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_8]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_3, __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_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_4, __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_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_505] = [__v_8]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_8]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_3, __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_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_4, __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_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_5, __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_506] = { let __args: [G; IN_506] = [__v_5, __v_1]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_505] = [__v_10]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_10]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_505] = [__v_6]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_5, __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_506] = { let __args: [G; IN_506] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_505] = [__v_6]; - record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45502,15 +45501,15 @@ fn aiur_fn_505( }) } -const INPUT_SIZE_506: usize = 4; -const IN_506: usize = 4; -const OUT_506: usize = 1; -fn aiur_fn_506( - inp: [G; IN_506], +const INPUT_SIZE_507: usize = 4; +const IN_507: usize = 4; +const OUT_507: usize = 1; +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]; @@ -45521,8 +45520,8 @@ fn aiur_fn_506( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_506] = [__v_5]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_507] = [__v_5]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -45531,15 +45530,15 @@ fn aiur_fn_506( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_506] = [__v_6]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_507] = [__v_6]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_6]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_6]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_2, __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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -45558,18 +45557,18 @@ fn aiur_fn_506( match __v_15.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); - let __ret: [G; OUT_506] = [__v_20]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_507] = [__v_20]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { 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_507] = { let __args: [G; IN_507] = [__v_11, __v_14, __v_15, __v_22, __v_2, __v_3]; 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_11, __v_14, __v_15, __v_22, __v_2, __v_3]; 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_23: G = __r_arr[0]; - let __ret: [G; OUT_506] = [__v_23]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_507] = [__v_23]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45581,8 +45580,8 @@ fn aiur_fn_506( }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_506] = [__v_6]; - record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_507] = [__v_6]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45594,15 +45593,15 @@ fn aiur_fn_506( }) } -const INPUT_SIZE_507: usize = 6; -const IN_507: usize = 6; -const OUT_507: usize = 1; -fn aiur_fn_507( - inp: [G; IN_507], +const INPUT_SIZE_508: usize = 6; +const IN_508: usize = 6; +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_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]; @@ -45616,10 +45615,10 @@ fn aiur_fn_507( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; 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_2, __v_6, __v_3, __v_4, __v_5, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_507] = [__v_10]; - record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_508] = [__v_10]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45634,16 +45633,16 @@ fn aiur_fn_507( let __v_11: G = { let __values: [G; 3] = [__v_10, __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_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_8, __v_13, __v_2, __v_11, __v_4, __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_8, __v_13, __v_2, __v_11, __v_4, __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_14: G = __r_arr[0]; - let __ret: [G; OUT_507] = [__v_14]; - record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_508] = [__v_14]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_507] = [__v_10]; - record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_508] = [__v_10]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45652,15 +45651,15 @@ fn aiur_fn_507( }) } -const INPUT_SIZE_508: usize = 7; -const IN_508: usize = 7; -const OUT_508: usize = 1; -fn aiur_fn_508( - inp: [G; IN_508], +const INPUT_SIZE_509: usize = 7; +const IN_509: usize = 7; +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]; @@ -45675,10 +45674,10 @@ fn aiur_fn_508( let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_6, __v_9]; 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_6, __v_9]; 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 __ret: [G; OUT_508] = [__v_10]; - record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_509] = [__v_10]; + record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45717,16 +45716,16 @@ fn aiur_fn_508( let __v_24: G = { let __values: [G; 3] = [__v_23, __v_9, __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_25: G = G::from_u64(1); let __v_26: G = (__v_2 + __v_25); - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_10, __v_1, __v_26, __v_24, __v_4, __v_5, __v_22]; 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_10, __v_1, __v_26, __v_24, __v_4, __v_5, __v_22]; 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 __ret: [G; OUT_508] = [__v_27]; - record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_509] = [__v_27]; + record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_508] = [__v_12]; - record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_509] = [__v_12]; + record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45735,15 +45734,15 @@ fn aiur_fn_508( }) } -const INPUT_SIZE_509: usize = 2; -const IN_509: usize = 2; -const OUT_509: usize = 1; -fn aiur_fn_509( - inp: [G; IN_509], +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_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]; @@ -45754,25 +45753,25 @@ fn aiur_fn_509( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_509] = [__v_5]; - record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_510] = [__v_5]; + record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_1, __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_511] = { let __args: [G; IN_511] = [__v_1, __v_3]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_509] = [__v_6]; - record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_510] = [__v_6]; + record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_4, __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_4, __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_6: G = __r_arr[0]; - let __ret: [G; OUT_509] = [__v_6]; - record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_510] = [__v_6]; + record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45787,15 +45786,15 @@ fn aiur_fn_509( }) } -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]; @@ -45806,8 +45805,8 @@ fn aiur_fn_510( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_510] = [__v_5]; - record.function_queries[510].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)); return Ok(__ret); }, 0u64 => { @@ -45822,24 +45821,24 @@ fn aiur_fn_510( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_510] = [__v_10]; - record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_511] = [__v_10]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_4, __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_511] = { let __args: [G; IN_511] = [__v_4, __v_1]; 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 __ret: [G; OUT_510] = [__v_10]; - record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_511] = [__v_10]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_4, __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_511] = { let __args: [G; IN_511] = [__v_4, __v_1]; 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_9: G = __r_arr[0]; - let __ret: [G; OUT_510] = [__v_9]; - record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_511] = [__v_9]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -45851,15 +45850,15 @@ fn aiur_fn_510( }) } -const INPUT_SIZE_511: usize = 9; -const IN_511: usize = 9; -const OUT_511: usize = 1; -fn aiur_fn_511( - inp: [G; IN_511], +const INPUT_SIZE_512: usize = 9; +const IN_512: usize = 9; +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]; @@ -45873,17 +45872,17 @@ fn aiur_fn_511( let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_9, __v_2, __v_6, __v_7, __v_8, __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_9, __v_2, __v_6, __v_7, __v_8, __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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_11, __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_11, __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_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_512] = { let __args: [G; IN_512] = [__v_15, __v_6, __v_3, __v_7, __v_8]; 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_15, __v_6, __v_3, __v_7, __v_8]; 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_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_16, __v_3, __v_17]; 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_16, __v_3, __v_17]; 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_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); @@ -45891,23 +45890,23 @@ fn aiur_fn_511( 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_524] = { let __args: [G; IN_524] = [__v_24, __v_12]; 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_24, __v_12]; 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_25: G = __r_arr[0]; - let __ret: [G; OUT_511] = [__v_25]; - record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_512] = [__v_25]; + 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]; @@ -45917,32 +45916,32 @@ fn aiur_fn_512( match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_0, __v_1, __v_2, __v_5]; 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_0, __v_1, __v_2, __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]; - let __ret: [G; OUT_512] = [__v_6]; - record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_513] = [__v_6]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __v_4, __v_2]; 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_0, __v_4, __v_2]; 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_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_513] = [__v_5]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_513: usize = 3; -const IN_513: usize = 3; -const OUT_513: usize = 1; -fn aiur_fn_513( - inp: [G; IN_513], +const INPUT_SIZE_514: usize = 3; +const IN_514: usize = 3; +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_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]; @@ -45953,8 +45952,8 @@ fn aiur_fn_513( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_513] = [__v_0]; - record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_514] = [__v_0]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -45964,10 +45963,10 @@ fn aiur_fn_513( 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_513] = { let __args: [G; IN_513] = [__v_10, __v_5, __v_2]; 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_10, __v_5, __v_2]; 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 __ret: [G; OUT_513] = [__v_11]; - record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_514] = [__v_11]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -45977,15 +45976,15 @@ fn aiur_fn_513( }) } -const INPUT_SIZE_514: usize = 6; -const IN_514: usize = 6; -const OUT_514: usize = 1; -fn aiur_fn_514( - inp: [G; IN_514], +const INPUT_SIZE_515: usize = 6; +const IN_515: usize = 6; +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]; @@ -45995,8 +45994,8 @@ fn aiur_fn_514( let __v_5: G = inp[5]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_514] = [__v_0]; - record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_515] = [__v_0]; + record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46007,7 +46006,7 @@ fn aiur_fn_514( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_5, __v_2, __v_3, __v_4]; 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_5, __v_2, __v_3, __v_4]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_10, __v_11]; 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)? } }; @@ -46016,10 +46015,10 @@ fn aiur_fn_514( 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_514] = { let __args: [G; IN_514] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; 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_12, __v_14, __v_2, __v_3, __v_4, __v_16]; 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_17: G = __r_arr[0]; - let __ret: [G; OUT_514] = [__v_17]; - record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_515] = [__v_17]; + record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46031,15 +46030,15 @@ fn aiur_fn_514( }) } -const INPUT_SIZE_515: usize = 4; -const IN_515: usize = 4; -const OUT_515: usize = 1; -fn aiur_fn_515( - inp: [G; IN_515], +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_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]; @@ -46053,8 +46052,8 @@ fn aiur_fn_515( 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_515] = [__v_9]; - record.function_queries[515].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)); return Ok(__ret); }, _ => { @@ -46063,10 +46062,10 @@ fn aiur_fn_515( 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_726] = { let __args: [G; IN_726] = [__v_3, __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_729] = { let __args: [G; IN_729] = [__v_3, __v_0]; 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 __ret: [G; OUT_515] = [__v_6]; - record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_516] = [__v_6]; + record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46076,8 +46075,8 @@ fn aiur_fn_515( 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_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); }, } @@ -46086,15 +46085,15 @@ fn aiur_fn_515( }) } -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]; @@ -46104,37 +46103,37 @@ fn aiur_fn_516( 0u64 => { let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1]; 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 __ret: [G; OUT_516] = [__v_4]; - record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_517] = [__v_4]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_0, __v_1, __v_4, __v_5, __v_3, __v_6]; 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_0, __v_1, __v_4, __v_5, __v_3, __v_6]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_516] = [__v_7]; - record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_517] = [__v_7]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_517: usize = 2; -const IN_517: usize = 2; -const OUT_517: usize = 1; -fn aiur_fn_517( - inp: [G; IN_517], +const INPUT_SIZE_518: usize = 2; +const IN_518: usize = 2; +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]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __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_729] = { let __args: [G; IN_729] = [__v_1, __v_0]; 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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -46150,29 +46149,29 @@ fn aiur_fn_517( let __v_13: G = __loaded[10]; match __v_3.as_canonical_u64() { 6u64 => { - 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); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_517] = [__v_14]; - record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_518] = [__v_14]; + record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_518: usize = 6; -const IN_518: usize = 6; -const OUT_518: usize = 1; -fn aiur_fn_518( - inp: [G; IN_518], +const INPUT_SIZE_519: usize = 6; +const IN_519: usize = 6; +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]; @@ -46182,8 +46181,8 @@ fn aiur_fn_518( let __v_5: G = inp[5]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_518] = [__v_0]; - record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_519] = [__v_0]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46194,7 +46193,7 @@ fn aiur_fn_518( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_5, __v_2, __v_3, __v_4]; 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_2, __v_3, __v_4]; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_10, __v_11]; 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)? } }; @@ -46203,10 +46202,10 @@ fn aiur_fn_518( 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_518] = { let __args: [G; IN_518] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; 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_12, __v_14, __v_2, __v_3, __v_4, __v_16]; 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_17: G = __r_arr[0]; - let __ret: [G; OUT_518] = [__v_17]; - record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_519] = [__v_17]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46218,15 +46217,15 @@ fn aiur_fn_518( }) } -const INPUT_SIZE_519: usize = 4; -const IN_519: usize = 4; -const OUT_519: usize = 1; -fn aiur_fn_519( - inp: [G; IN_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], 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]; @@ -46240,8 +46239,8 @@ fn aiur_fn_519( 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_519] = [__v_9]; - record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_520] = [__v_9]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46250,13 +46249,13 @@ fn aiur_fn_519( 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_726] = { let __args: [G; IN_726] = [__v_3, __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_729] = { let __args: [G; IN_729] = [__v_3, __v_0]; 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 __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_6, __v_1, __v_7]; 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_8: G = __r_arr[0]; - 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); }, _ => { @@ -46266,8 +46265,8 @@ fn aiur_fn_519( 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_519] = [__v_11]; - record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_520] = [__v_11]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46276,15 +46275,15 @@ fn aiur_fn_519( }) } -const INPUT_SIZE_520: usize = 2; -const IN_520: usize = 2; -const OUT_520: usize = 1; -fn aiur_fn_520( - inp: [G; IN_520], +const INPUT_SIZE_521: usize = 2; +const IN_521: usize = 2; +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]; @@ -46293,8 +46292,8 @@ fn aiur_fn_520( 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_520] = [__v_4]; - record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_521] = [__v_4]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46308,11 +46307,11 @@ fn aiur_fn_520( 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_520] = { let __args: [G; IN_520] = [__v_4, __v_8]; 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_8]; 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_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_520] = [__v_10]; - record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_521] = [__v_10]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46324,15 +46323,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]; @@ -46343,8 +46342,8 @@ fn aiur_fn_521( 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_521] = [__v_6]; - record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_522] = [__v_6]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46355,26 +46354,26 @@ fn aiur_fn_521( 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_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_10]; 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_0, __v_1, __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 __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_521] = [__v_12]; - record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_522] = [__v_12]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_522: usize = 4; -const IN_522: usize = 4; -const OUT_522: usize = 1; -fn aiur_fn_522( - inp: [G; IN_522], +const INPUT_SIZE_523: usize = 4; +const IN_523: usize = 4; +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]; @@ -46383,8 +46382,8 @@ fn aiur_fn_522( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_522] = [__v_0]; - record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_523] = [__v_0]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46400,25 +46399,25 @@ fn aiur_fn_522( 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_522] = { let __args: [G; IN_522] = [__v_14, __v_1, __v_2, __v_16]; 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_14, __v_1, __v_2, __v_16]; 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_17: G = __r_arr[0]; - let __ret: [G; OUT_522] = [__v_17]; - record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_523] = [__v_17]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_523: usize = 3; -const IN_523: usize = 3; -const OUT_523: usize = 1; -fn aiur_fn_523( - inp: [G; IN_523], +const INPUT_SIZE_524: usize = 3; +const IN_524: usize = 3; +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]; @@ -46426,8 +46425,8 @@ fn aiur_fn_523( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_523] = [__v_0]; - record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_524] = [__v_0]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46442,25 +46441,25 @@ fn aiur_fn_523( 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_523] = { let __args: [G; IN_523] = [__v_12, __v_1, __v_14]; 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_12, __v_1, __v_14]; 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_15: G = __r_arr[0]; - let __ret: [G; OUT_523] = [__v_15]; - record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_524] = [__v_15]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -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_525: usize = 2; +const IN_525: usize = 2; +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 __v_1: G = inp[1]; @@ -46470,18 +46469,18 @@ fn aiur_fn_524( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_524] = [__v_0]; - record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_525] = [__v_0]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_4]; 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_0, __v_4]; 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_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_524] = [__v_8]; - record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_525] = [__v_8]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46491,15 +46490,15 @@ fn aiur_fn_524( }) } -const INPUT_SIZE_525: usize = 15; -const IN_525: usize = 15; -const OUT_525: usize = 1; -fn aiur_fn_525( - inp: [G; IN_525], +const INPUT_SIZE_526: usize = 15; +const IN_526: usize = 15; +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 __v_1: G = inp[1]; @@ -46520,13 +46519,13 @@ fn aiur_fn_525( let __v_15: G = __r_arr[0]; let __v_16: G = (__v_10 + __v_11); let __v_17: G = (__v_9 + __v_16); - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_13]; 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_1, __v_13]; 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_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_15, __v_18, __v_17, __v_3, __v_4, __v_19]; 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_15, __v_18, __v_17, __v_3, __v_4, __v_19]; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_7, __v_0, __v_21]; 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] = [__v_7, __v_0, __v_21]; 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_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = G::from_u64(1); @@ -46542,7 +46541,7 @@ fn aiur_fn_525( let __v_34: G = G::from_u64(1); let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_20, __v_6, __v_26, __v_29, __v_32, __v_35, __v_13, __v_14, __v_36]; 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_529] = { let __args: [G; IN_529] = [__v_20, __v_6, __v_26, __v_29, __v_32, __v_35, __v_13, __v_14, __v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -46556,10 +46555,10 @@ fn aiur_fn_525( let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_46, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_46, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_47, __v_42, __v_48]; 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_539] = { let __args: [G; IN_539] = [__v_47, __v_42, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_44 - __v_50); @@ -46573,10 +46572,10 @@ fn aiur_fn_525( let __v_58: G = G::from_u64(2); let __v_59: G = G::from_u64(0); let __v_60: G = { let __values: [G; 4] = [__v_58, __v_1, __v_5, __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 __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_60, __v_18, __v_9, __v_44, __v_3, __v_4]; 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_60, __v_18, __v_9, __v_44, __v_3, __v_4]; 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_61: G = __r_arr[0]; let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_61, __v_41, __v_43, __v_62]; 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_61, __v_41, __v_43, __v_62]; 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_63: G = __r_arr[0]; let __v_64: G = G::from_u64(3); let __v_65: G = G::from_u64(0); @@ -46585,27 +46584,27 @@ fn aiur_fn_525( 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_70: G = G::from_u64(0); - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_38, __v_39, __v_37, __v_8, __v_12, __v_41, __v_17, __v_69, __v_13, __v_14, __v_70]; 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_597] = { let __args: [G; IN_597] = [__v_38, __v_39, __v_37, __v_8, __v_12, __v_41, __v_17, __v_69, __v_13, __v_14, __v_70]; 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_71: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_66, __v_71]; 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_66, __v_71]; 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_72: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_72, __v_37]; 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_72, __v_37]; 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_73: G = __r_arr[0]; - let __ret: [G; OUT_525] = [__v_73]; - record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_526] = [__v_73]; + record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_526: usize = 6; -const IN_526: usize = 6; -const OUT_526: usize = 1; -fn aiur_fn_526( - inp: [G; IN_526], +const INPUT_SIZE_527: usize = 6; +const IN_527: usize = 6; +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]; @@ -46618,32 +46617,32 @@ fn aiur_fn_526( 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_539] = { let __args: [G; IN_539] = [__v_0, __v_2, __v_7, __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_2, __v_7, __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 __ret: [G; OUT_526] = [__v_9]; - record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_527] = [__v_9]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __v_5, __v_3]; 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_0, __v_5, __v_3]; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_526] = [__v_6]; - record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_527] = [__v_6]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_527: usize = 4; -const IN_527: usize = 4; -const OUT_527: usize = 1; -fn aiur_fn_527( - inp: [G; IN_527], +const INPUT_SIZE_528: usize = 4; +const IN_528: usize = 4; +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]; @@ -46651,8 +46650,8 @@ fn aiur_fn_527( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_527] = [__v_0]; - record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_528] = [__v_0]; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46676,10 +46675,10 @@ fn aiur_fn_527( let __v_17: G = (__v_1 - __v_16); let __v_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_15, __v_17, __v_2, __v_19]; 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_15, __v_17, __v_2, __v_19]; 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_20: G = __r_arr[0]; - let __ret: [G; OUT_527] = [__v_20]; - record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_528] = [__v_20]; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46691,15 +46690,15 @@ fn aiur_fn_527( }) } -const INPUT_SIZE_528: usize = 9; -const IN_528: usize = 9; -const OUT_528: usize = 4; -fn aiur_fn_528( - inp: [G; IN_528], +const INPUT_SIZE_529: usize = 9; +const IN_529: usize = 9; +const OUT_529: usize = 4; +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 __v_1: G = inp[1]; @@ -46717,7 +46716,7 @@ fn aiur_fn_528( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_1, __v_5, __v_6, __v_7]; 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_10, __v_1, __v_5, __v_6, __v_7]; 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 __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); @@ -46732,57 +46731,57 @@ fn aiur_fn_528( let __v_22: G = { let __values: [G; 3] = [__v_21, __v_14, __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_23: G = G::from_u64(1); let __v_24: G = (__v_8 + __v_23); - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_11, __v_1, __v_16, __v_20, __v_22, __v_18, __v_6, __v_7, __v_24]; 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_529] = { let __args: [G; IN_529] = [__v_11, __v_1, __v_16, __v_20, __v_22, __v_18, __v_6, __v_7, __v_24]; 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_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __v_28: G = __r_arr[3]; - let __ret: [G; OUT_528] = [__v_25, __v_26, __v_27, __v_28]; - record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_25, __v_26, __v_27, __v_28]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = (__v_8 + __v_19); - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_11, __v_1, __v_16, __v_3, __v_4, __v_18, __v_6, __v_7, __v_20]; 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_529] = { let __args: [G; IN_529] = [__v_11, __v_1, __v_16, __v_3, __v_4, __v_18, __v_6, __v_7, __v_20]; 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_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 __ret: [G; OUT_528] = [__v_21, __v_22, __v_23, __v_24]; - record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_21, __v_22, __v_23, __v_24]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; 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_727] = { let __args: [G; IN_727] = [__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_13: G = __r_arr[0]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3]; 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_727] = { let __args: [G; IN_727] = [__v_3]; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_727] = { let __args: [G; IN_727] = [__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_15: G = __r_arr[0]; - let __ret: [G; OUT_528] = [__v_13, __v_14, __v_15, __v_0]; - record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_529] = [__v_13, __v_14, __v_15, __v_0]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_529: usize = 2; -const IN_529: usize = 2; -const OUT_529: usize = 1; -fn aiur_fn_529( - inp: [G; IN_529], +const INPUT_SIZE_530: usize = 2; +const IN_530: usize = 2; +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]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __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_729] = { let __args: [G; IN_729] = [__v_1, __v_0]; 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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -46831,7 +46830,7 @@ fn aiur_fn_529( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 32] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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 __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_13, __v_46]; 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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10, __v_46]; 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_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 1u64 => { @@ -46840,16 +46839,16 @@ fn aiur_fn_529( 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_52: G = { let __values: [G; 3] = [__v_48, __v_0, __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_529] = [__v_52]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_52]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_13, __v_1, __v_48]; 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_10, __v_1, __v_48]; 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_49: G = __r_arr[0]; - let __ret: [G; OUT_529] = [__v_49]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_49]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -46863,23 +46862,23 @@ fn aiur_fn_529( 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_14, __v_0, __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_529] = [__v_18]; - record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_530] = [__v_18]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_530: usize = 3; -const IN_530: usize = 3; -const OUT_530: usize = 1; -fn aiur_fn_530( - inp: [G; IN_530], +const INPUT_SIZE_531: usize = 3; +const IN_531: usize = 3; +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 __v_1: G = inp[1]; @@ -46893,8 +46892,8 @@ fn aiur_fn_530( 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_530] = [__v_8]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_8]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -46912,27 +46911,27 @@ fn aiur_fn_530( let __v_16: G = __loaded[10]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_16, __v_0]; 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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_0]; 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_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = (__v_2 + __v_19); - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_5, __v_20]; 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_0, __v_5, __v_20]; 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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_18, __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 __ret: [G; OUT_530] = [__v_22]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_22]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_18: G = G::from_u64(1); let __v_19: G = (__v_2 + __v_18); - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_5, __v_19]; 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_0, __v_5, __v_19]; 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 = __r_arr[0]; - 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); }, _ => { @@ -46943,10 +46942,10 @@ fn aiur_fn_530( _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_2 + __v_17); - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_5, __v_18]; 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_0, __v_5, __v_18]; 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_19: G = __r_arr[0]; - let __ret: [G; OUT_530] = [__v_19]; - record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_531] = [__v_19]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -46958,20 +46957,20 @@ fn aiur_fn_530( }) } -const INPUT_SIZE_531: usize = 3; -const IN_531: usize = 3; -const OUT_531: usize = 1; -fn aiur_fn_531( - inp: [G; IN_531], +const INPUT_SIZE_532: usize = 3; +const IN_532: usize = 3; +const OUT_532: usize = 1; +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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_1]; 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_729] = { let __args: [G; IN_729] = [__v_2, __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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -47020,17 +47019,17 @@ fn aiur_fn_531( let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 32] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_14, __v_47]; 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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_11, __v_47]; 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_48: G = __r_arr[0]; match __v_48.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_531] = [__v_49]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_532] = [__v_49]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __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_729] = { let __args: [G; IN_729] = [__v_2, __v_0]; 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_49: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_50: G = __loaded[0]; @@ -47046,16 +47045,16 @@ fn aiur_fn_531( let __v_60: G = __loaded[10]; match __v_50.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_60, __v_14]; 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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_57, __v_11]; 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_61: G = __r_arr[0]; - let __ret: [G; OUT_531] = [__v_61]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_532] = [__v_61]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_61: G = G::from_u64(0); - let __ret: [G; OUT_531] = [__v_61]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_532] = [__v_61]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47067,35 +47066,35 @@ fn aiur_fn_531( }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_531] = [__v_15]; - record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_532] = [__v_15]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_532: usize = 5; -const IN_532: usize = 5; -const OUT_532: usize = 2; -fn aiur_fn_532( - inp: [G; IN_532], +const INPUT_SIZE_533: usize = 5; +const IN_533: usize = 5; +const OUT_533: usize = 2; +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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0]; 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_0]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_5]; 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_727] = { let __args: [G; IN_727] = [__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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_7, __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_724] = { let __args: [G; IN_724] = [__v_7, __v_2]; 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_8: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_8, __v_3, __v_4]; 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]; @@ -47110,33 +47109,33 @@ fn aiur_fn_532( match __v_12.as_canonical_u64() { 2u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_13, __v_11, __v_16]; 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_1, __v_13, __v_11, __v_16]; 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_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_532] = [__v_17, __v_18]; - record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_533] = [__v_17, __v_18]; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_532] = [__v_16, __v_17]; - record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_533] = [__v_16, __v_17]; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_533: usize = 4; -const IN_533: usize = 4; -const OUT_533: usize = 2; -fn aiur_fn_533( - inp: [G; IN_533], +const INPUT_SIZE_534: usize = 4; +const IN_534: usize = 4; +const OUT_534: usize = 2; +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]; @@ -47153,31 +47152,31 @@ fn aiur_fn_533( 1u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_533] = [__v_10, __v_11]; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_534] = [__v_10, __v_11]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_10: G = (__v_5 - __v_1); match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_2, __v_7]; 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_7]; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_533] = [__v_12, __v_3]; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_534] = [__v_12, __v_3]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_1, __v_2, __v_13]; 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_9, __v_1, __v_2, __v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_533] = [__v_14, __v_15]; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_534] = [__v_14, __v_15]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47185,11 +47184,11 @@ fn aiur_fn_533( _ => { let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_1, __v_2, __v_12]; 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_9, __v_1, __v_2, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_533] = [__v_13, __v_14]; - record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_534] = [__v_13, __v_14]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47201,15 +47200,15 @@ fn aiur_fn_533( }) } -const INPUT_SIZE_534: usize = 2; -const IN_534: usize = 2; -const OUT_534: usize = 1; -fn aiur_fn_534( - inp: [G; IN_534], +const INPUT_SIZE_535: usize = 2; +const IN_535: usize = 2; +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_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]; @@ -47220,8 +47219,8 @@ fn aiur_fn_534( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_534] = [__v_5]; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_535] = [__v_5]; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -47232,25 +47231,25 @@ fn aiur_fn_534( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_534] = [__v_8]; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_535] = [__v_8]; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_6, __v_3]; 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_564] = { let __args: [G; IN_564] = [__v_6, __v_3]; 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 __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_7, __v_4]; 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_7, __v_4]; 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_9: G = __r_arr[0]; - let __ret: [G; OUT_534] = [__v_9]; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_535] = [__v_9]; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_534] = [__v_9]; - record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_535] = [__v_9]; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47267,15 +47266,15 @@ fn aiur_fn_534( }) } -const INPUT_SIZE_535: usize = 3; -const IN_535: usize = 3; -const OUT_535: usize = 2; -fn aiur_fn_535( - inp: [G; IN_535], +const INPUT_SIZE_536: usize = 3; +const IN_536: usize = 3; +const OUT_536: usize = 2; +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 = inp[0]; let __v_1: G = inp[1]; @@ -47288,8 +47287,8 @@ fn aiur_fn_535( 1u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_535] = [__v_6, __v_7]; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_536] = [__v_6, __v_7]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -47297,18 +47296,18 @@ fn aiur_fn_535( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_535] = [__v_7, __v_2]; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_536] = [__v_7, __v_2]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_5, __v_1, __v_8]; 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] = [__v_5, __v_1, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_535] = [__v_9, __v_10]; - record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_536] = [__v_9, __v_10]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47320,40 +47319,40 @@ fn aiur_fn_535( }) } -const INPUT_SIZE_536: usize = 1; -const IN_536: usize = 1; -const OUT_536: usize = 2; -fn aiur_fn_536( - inp: [G; IN_536], +const INPUT_SIZE_537: usize = 1; +const IN_537: usize = 1; +const OUT_537: usize = 2; +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 = 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_537] = { let __args: [G; IN_537] = [__v_0, __v_3]; 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_538] = { let __args: [G; IN_538] = [__v_0, __v_3]; 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 __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_727] = { let __args: [G; IN_727] = [__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_6: G = __r_arr[0]; - let __ret: [G; OUT_536] = [__v_6, __v_5]; - record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_537] = [__v_6, __v_5]; + record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_537: usize = 2; -const IN_537: usize = 2; -const OUT_537: usize = 2; -fn aiur_fn_537( - inp: [G; IN_537], +const INPUT_SIZE_538: usize = 2; +const IN_538: usize = 2; +const OUT_538: usize = 2; +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 = inp[0]; let __v_1: G = inp[1]; @@ -47366,31 +47365,31 @@ fn aiur_fn_537( 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_537] = { let __args: [G; IN_537] = [__v_4, __v_7]; 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_538] = { let __args: [G; IN_538] = [__v_4, __v_7]; 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 __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_537] = [__v_8, __v_9]; - record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_538] = [__v_8, __v_9]; + record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_537] = [__v_1, __v_0]; - record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_538] = [__v_1, __v_0]; + record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_538: usize = 3; -const IN_538: usize = 3; -const OUT_538: usize = 1; -fn aiur_fn_538( - inp: [G; IN_538], +const INPUT_SIZE_539: usize = 3; +const IN_539: usize = 3; +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_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]; @@ -47404,19 +47403,19 @@ fn aiur_fn_538( 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_538] = [__v_8]; - record.function_queries[538].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)); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_1, __v_2]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_5, __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 __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_5, __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 __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_538] = [__v_9]; - record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_539] = [__v_9]; + record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47426,15 +47425,15 @@ fn aiur_fn_538( }) } -const INPUT_SIZE_539: usize = 4; -const IN_539: usize = 4; -const OUT_539: usize = 1; -fn aiur_fn_539( - inp: [G; IN_539], +const INPUT_SIZE_540: usize = 4; +const IN_540: usize = 4; +const OUT_540: usize = 1; +fn aiur_fn_540( + inp: [G; IN_540], 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]; @@ -47443,8 +47442,8 @@ fn aiur_fn_539( let __v_4: G = (__v_1 - __v_3); match __v_4.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); }, _ => { @@ -47457,25 +47456,25 @@ fn aiur_fn_539( 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_539] = { let __args: [G; IN_539] = [__v_11, __v_1, __v_2, __v_13]; 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_11, __v_1, __v_2, __v_13]; 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 __ret: [G; OUT_539] = [__v_14]; - record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_540] = [__v_14]; + record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_540: usize = 4; -const IN_540: usize = 4; -const OUT_540: usize = 1; -fn aiur_fn_540( - inp: [G; IN_540], +const INPUT_SIZE_541: usize = 4; +const IN_541: usize = 4; +const OUT_541: usize = 1; +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]; @@ -47484,8 +47483,8 @@ fn aiur_fn_540( let __v_4: G = (__v_1 - __v_3); match __v_4.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_541] = [__v_0]; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47500,59 +47499,59 @@ fn aiur_fn_540( 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_540] = { let __args: [G; IN_540] = [__v_13, __v_1, __v_2, __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_1, __v_2, __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 = __r_arr[0]; - let __ret: [G; OUT_540] = [__v_16]; - record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_541] = [__v_16]; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_541: usize = 2; -const IN_541: usize = 2; -const OUT_541: usize = 2; -fn aiur_fn_541( - inp: [G; IN_541], +const INPUT_SIZE_542: usize = 2; +const IN_542: usize = 2; +const OUT_542: usize = 2; +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]; 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_542] = { let __args: [G; IN_542] = [__v_0, __v_1, __v_4]; 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_0, __v_1, __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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_5]; 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_727] = { let __args: [G; IN_727] = [__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_7: G = __r_arr[0]; - let __ret: [G; OUT_541] = [__v_7, __v_6]; - record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_542] = [__v_7, __v_6]; + record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_542: usize = 3; -const IN_542: usize = 3; -const OUT_542: usize = 2; -fn aiur_fn_542( - inp: [G; IN_542], +const INPUT_SIZE_543: usize = 3; +const IN_543: usize = 3; +const OUT_543: usize = 2; +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]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_542] = [__v_2, __v_0]; - record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_543] = [__v_2, __v_0]; + record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47567,11 +47566,11 @@ fn aiur_fn_542( let __v_8: G = (__v_1 - __v_7); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __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_542] = { let __args: [G; IN_542] = [__v_5, __v_8, __v_10]; 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_5, __v_8, __v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_542] = [__v_11, __v_12]; - record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_543] = [__v_11, __v_12]; + record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47583,15 +47582,15 @@ fn aiur_fn_542( }) } -const INPUT_SIZE_543: usize = 3; -const IN_543: usize = 3; -const OUT_543: usize = 1; -fn aiur_fn_543( - inp: [G; IN_543], +const INPUT_SIZE_544: usize = 3; +const IN_544: usize = 3; +const OUT_544: usize = 1; +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]; @@ -47599,8 +47598,8 @@ fn aiur_fn_543( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_543] = [__v_0]; - record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_544] = [__v_0]; + record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47613,25 +47612,25 @@ fn aiur_fn_543( 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_543] = { let __args: [G; IN_543] = [__v_10, __v_1, __v_12]; 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_544] = { let __args: [G; IN_544] = [__v_10, __v_1, __v_12]; 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_13: G = __r_arr[0]; - let __ret: [G; OUT_543] = [__v_13]; - record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_544] = [__v_13]; + record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_544: usize = 14; -const IN_544: usize = 14; -const OUT_544: usize = 1; -fn aiur_fn_544( - inp: [G; IN_544], +const INPUT_SIZE_545: usize = 14; +const IN_545: usize = 14; +const OUT_545: usize = 1; +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]; @@ -47656,12 +47655,12 @@ fn aiur_fn_544( let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_544] = [__v_19]; - record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_545] = [__v_19]; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_11, __v_15]; 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_729] = { let __args: [G; IN_729] = [__v_11, __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_17: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; @@ -47677,16 +47676,16 @@ fn aiur_fn_544( let __v_28: G = __loaded[10]; match __v_18.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_1, __v_15, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13, __v_10, __v_11, __v_12]; 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_1, __v_15, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13, __v_10, __v_11, __v_12]; 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_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); let __v_31: G = (__v_13 + __v_30); - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_31]; 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_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_31]; 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_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 3] = [__v_33, __v_29, __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 __ret: [G; OUT_544] = [__v_34]; - record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_545] = [__v_34]; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -47701,15 +47700,15 @@ fn aiur_fn_544( }) } -const INPUT_SIZE_545: usize = 7; -const IN_545: usize = 7; -const OUT_545: usize = 1; -fn aiur_fn_545( - inp: [G; IN_545], +const INPUT_SIZE_546: usize = 7; +const IN_546: usize = 7; +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_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]; @@ -47719,23 +47718,23 @@ fn aiur_fn_545( 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_546] = { let __args: [G; IN_546] = [__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[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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_545] = [__v_8]; - record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_546] = [__v_8]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_546: usize = 8; -const IN_546: usize = 8; -const OUT_546: usize = 1; -fn aiur_fn_546( - inp: [G; IN_546], +const INPUT_SIZE_547: usize = 8; +const IN_547: usize = 8; +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]; @@ -47757,12 +47756,12 @@ fn aiur_fn_546( 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_546] = [__v_16]; - record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_547] = [__v_16]; + record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_6, __v_9]; 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_729] = { let __args: [G; IN_729] = [__v_6, __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_14: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -47778,7 +47777,7 @@ fn aiur_fn_546( let __v_25: G = __loaded[10]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_9, __v_17, __v_18, __v_19, __v_12, __v_3, __v_5, __v_10, __v_11]; 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_9, __v_17, __v_18, __v_19, __v_12, __v_3, __v_5, __v_10, __v_11]; 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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_26, __v_7, __v_27]; 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)? } }; @@ -47786,18 +47785,18 @@ fn aiur_fn_546( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(1); let __v_31: G = (__v_7 + __v_30); - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_31]; 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_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_31]; 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_32: G = __r_arr[0]; let __v_33: G = { let __values: [G; 3] = [__v_29, __v_28, __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 __ret: [G; OUT_546] = [__v_33]; - record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_547] = [__v_33]; + record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_26: G = __r_arr[0]; - let __ret: [G; OUT_546] = [__v_26]; - record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_547] = [__v_26]; + record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47809,15 +47808,15 @@ fn aiur_fn_546( }) } -const INPUT_SIZE_547: usize = 11; -const IN_547: usize = 11; -const OUT_547: usize = 1; -fn aiur_fn_547( - inp: [G; IN_547], +const INPUT_SIZE_548: usize = 11; +const IN_548: usize = 11; +const OUT_548: usize = 1; +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]; @@ -47830,23 +47829,23 @@ fn aiur_fn_547( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_0, __v_1, __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[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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_0, __v_1, __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[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_11: G = __r_arr[0]; - let __ret: [G; OUT_547] = [__v_11]; - record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_548] = [__v_11]; + record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_548: usize = 12; -const IN_548: usize = 12; -const OUT_548: usize = 1; -fn aiur_fn_548( - inp: [G; IN_548], +const INPUT_SIZE_549: usize = 12; +const IN_549: usize = 12; +const OUT_549: usize = 1; +fn aiur_fn_549( + inp: [G; IN_549], 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]; @@ -47872,12 +47871,12 @@ fn aiur_fn_548( let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_548] = [__v_20]; - record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_549] = [__v_20]; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_9, __v_13]; 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_729] = { let __args: [G; IN_729] = [__v_9, __v_13]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; @@ -47893,24 +47892,24 @@ fn aiur_fn_548( let __v_29: G = __loaded[10]; match __v_19.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_24, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11]; 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_24, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11]; 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_30: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_11 + __v_31); - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_32]; 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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_32]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_30, __v_33]; 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_724] = { let __args: [G; IN_724] = [__v_30, __v_33]; 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_34: G = __r_arr[0]; - let __ret: [G; OUT_548] = [__v_34]; - record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_549] = [__v_34]; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_17, __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[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 __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_17, __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[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_30: G = __r_arr[0]; - let __ret: [G; OUT_548] = [__v_30]; - record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_549] = [__v_30]; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -47922,15 +47921,15 @@ fn aiur_fn_548( }) } -const INPUT_SIZE_549: usize = 10; -const IN_549: usize = 10; -const OUT_549: usize = 1; -fn aiur_fn_549( - inp: [G; IN_549], +const INPUT_SIZE_550: usize = 10; +const IN_550: usize = 10; +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_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]; @@ -47945,7 +47944,7 @@ fn aiur_fn_549( let __v_10: G = (__v_6 + __v_4); let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1, __v_10]; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_11, __v_2, __v_8, __v_9]; 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_11, __v_2, __v_8, __v_9]; 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_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() { 1u64 => { @@ -47967,49 +47966,49 @@ fn aiur_fn_549( } }; let __v_13: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_7, __v_8]; 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_7, __v_8]; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_14, __v_12, __v_8]; 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_566] = { let __args: [G; IN_566] = [__v_14, __v_12, __v_8]; 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 __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_15]; 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]; 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_16: G = __r_arr[0]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_16, __v_0, __v_18]; 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] = [__v_16, __v_0, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_15, __v_20]; 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_15, __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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_25, __v_3]; 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_25, __v_3]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_15, __v_8]; 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_15, __v_8]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __v_3, __v_5, __v_13, __v_12, __v_3, __v_8]; 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_15, __v_3, __v_5, __v_13, __v_12, __v_3, __v_8]; 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_29: G = __r_arr[0]; let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_15, __v_16, __v_28, __v_3, __v_17, __v_5, __v_12, __v_3, __v_8, __v_9, __v_30]; 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 __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_15, __v_16, __v_28, __v_3, __v_17, __v_5, __v_12, __v_3, __v_8, __v_9, __v_30]; 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 __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_27, __v_4]; 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_27, __v_4]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = (__v_17 + __v_32); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_33, __v_35, __v_36]; 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_560] = { let __args: [G; IN_560] = [__v_33, __v_35, __v_36]; 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_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_16, __v_0, __v_38]; 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] = [__v_16, __v_0, __v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_15, __v_40]; 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_15, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -48022,10 +48021,10 @@ fn aiur_fn_549( let __v_50: G = (__v_3 + __v_49); let __v_51: G = G::from_u64(1); let __v_52: G = (__v_50 - __v_51); - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_47, __v_3, __v_52, __v_4, __v_42, __v_43]; 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_47, __v_3, __v_52, __v_4, __v_42, __v_43]; 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_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_53, __v_4, __v_54]; 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_53, __v_4, __v_54]; 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_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = (__v_50 + __v_56); @@ -48037,7 +48036,7 @@ fn aiur_fn_549( let __v_63: G = G::from_u64(0); let __v_64: G = { let __values: [G; 4] = [__v_62, __v_61, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0); - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_64, __v_4, __v_65]; 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_544] = { let __args: [G; IN_544] = [__v_64, __v_4, __v_65]; 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_66: G = __r_arr[0]; let __v_67: G = G::from_u64(3); let __v_68: G = G::from_u64(0); @@ -48049,29 +48048,29 @@ fn aiur_fn_549( let __v_74: G = G::from_u64(5); let __v_75: G = G::from_u64(0); let __v_76: G = { let __values: [G; 4] = [__v_74, __v_55, __v_73, __v_75]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_76, __v_37]; 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_76, __v_37]; 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_77: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_77, __v_31]; 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_77, __v_31]; 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_78: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_78, __v_29]; 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_78, __v_29]; 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_79: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_79, __v_26]; 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_79, __v_26]; 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_80: G = __r_arr[0]; - let __ret: [G; OUT_549] = [__v_80]; - record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_550] = [__v_80]; + record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_550: usize = 22; -const IN_550: usize = 22; -const OUT_550: usize = 1; -fn aiur_fn_550( - inp: [G; IN_550], +const INPUT_SIZE_551: usize = 22; +const IN_551: usize = 22; +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]; @@ -48097,13 +48096,13 @@ fn aiur_fn_550( let __v_21: G = inp[21]; let __v_22: G = (__v_8 + __v_9); let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_22, __v_23]; 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_22, __v_23]; 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_24: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_20]; 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_2, __v_20]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_25, __v_26, __v_17, __v_18]; 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_25, __v_26, __v_17, __v_18]; 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_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); @@ -48118,7 +48117,7 @@ fn aiur_fn_550( let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_27, __v_14, __v_30, __v_33, __v_36, __v_39, __v_20, __v_21, __v_40]; 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_529] = { let __args: [G; IN_529] = [__v_27, __v_14, __v_30, __v_33, __v_36, __v_39, __v_20, __v_21, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -48139,41 +48138,41 @@ fn aiur_fn_550( let __v_56: G = G::from_u64(0); let __v_57: G = { let __values: [G; 4] = [__v_55, __v_54, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_57, __v_45, __v_45, __v_58]; 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_57, __v_45, __v_45, __v_58]; 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_59: G = __r_arr[0]; let __v_60: G = G::from_u64(1); let __v_61: G = G::from_u64(1); let __v_62: G = { let __values: [G; 3] = [__v_60, __v_61, __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 = G::from_u64(0); - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_59, __v_42, __v_43, __v_41, __v_13, __v_16, __v_5, __v_6, __v_7, __v_45, __v_24, __v_62, __v_20, __v_21, __v_63]; 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_59, __v_42, __v_43, __v_41, __v_13, __v_16, __v_5, __v_6, __v_7, __v_45, __v_24, __v_62, __v_20, __v_21, __v_63]; 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_64: G = __r_arr[0]; let __v_65: G = (__v_6 + __v_7); let __v_66: G = G::from_u64(0); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_41, __v_65, __v_66]; 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_560] = { let __args: [G; IN_560] = [__v_41, __v_65, __v_66]; 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_67: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_64, __v_67]; 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_64, __v_67]; 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_68: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_68, __v_11]; 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_68, __v_11]; 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_69: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_69, __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_553] = { let __args: [G; IN_553] = [__v_69, __v_10]; 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_70: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_70, __v_12]; 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_70, __v_12]; 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_71: G = __r_arr[0]; - let __ret: [G; OUT_550] = [__v_71]; - record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_551] = [__v_71]; + 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]; @@ -48183,8 +48182,8 @@ fn aiur_fn_551( 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_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); }, _ => { @@ -48194,26 +48193,26 @@ fn aiur_fn_551( 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_551] = { let __args: [G; IN_551] = [__v_0, __v_8]; 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_0, __v_8]; 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_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_551] = [__v_10]; - record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_552] = [__v_10]; + record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); 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_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]; @@ -48223,18 +48222,18 @@ fn aiur_fn_552( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_552] = [__v_0]; - record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_553] = [__v_0]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_4]; 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_0, __v_4]; 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 __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_552] = [__v_8]; - record.function_queries[552].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)); return Ok(__ret); }, _ => { @@ -48244,15 +48243,15 @@ fn aiur_fn_552( }) } -const INPUT_SIZE_553: usize = 15; -const IN_553: usize = 15; -const OUT_553: usize = 1; -fn aiur_fn_553( - inp: [G; IN_553], +const INPUT_SIZE_554: usize = 15; +const IN_554: usize = 15; +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]; @@ -48275,21 +48274,21 @@ fn aiur_fn_553( let __v_17: G = __loaded[2]; match __v_15.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_553] = [__v_0]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_0]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_14]; 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_729] = { let __args: [G; IN_729] = [__v_2, __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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_18]; 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_729] = { let __args: [G; IN_729] = [__v_4, __v_18]; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_18]; 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_729] = { let __args: [G; IN_729] = [__v_5, __v_18]; 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_20: G = __r_arr[0]; let __v_21: G = (__v_8 + __v_9); let __v_22: G = (__v_7 + __v_21); let __v_23: G = (__v_6 + __v_22); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_16]; 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_729] = { let __args: [G; IN_729] = [__v_3, __v_16]; 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 __v_25: G = (__v_9 - __v_16); let __v_26: G = G::from_u64(0); @@ -48300,12 +48299,12 @@ fn aiur_fn_553( let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_11, __v_12, __v_13]; 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_30: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_30]; 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_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_31]; 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_727] = { let __args: [G; IN_727] = [__v_31]; 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_721] = { let __args: [G; IN_721] = [__v_33, __v_11]; 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_724] = { let __args: [G; IN_724] = [__v_33, __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_34: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_32, __v_34, __v_12, __v_13]; 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_35: G = __r_arr[0]; @@ -48318,25 +48317,25 @@ fn aiur_fn_553( let __v_41: G = G::from_u64(1); let __v_42: G = (__v_37 - __v_41); let __v_43: G = G::from_u64(0); - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_40, __v_6, __v_42, __v_43]; 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_40, __v_6, __v_42, __v_43]; 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_44: G = __r_arr[0]; let __v_45: G = G::from_u64(1); let __v_46: G = (__v_37 - __v_45); let __v_47: G = (__v_46 - __v_6); let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_44, __v_7, __v_47, __v_48]; 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_44, __v_7, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_37 - __v_50); let __v_52: G = (__v_51 - __v_6); let __v_53: G = (__v_52 - __v_7); let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_49, __v_8, __v_53, __v_54]; 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_49, __v_8, __v_53, __v_54]; 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_55: G = __r_arr[0]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_57, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_57, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_55, __v_58]; 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_59: G = __r_arr[0]; @@ -48348,22 +48347,22 @@ fn aiur_fn_553( let __v_65: G = G::from_u64(0); let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_65, __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(0); - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_66, __v_36, __v_67]; 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_66, __v_36, __v_67]; 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_68: G = __r_arr[0]; 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_59, __v_68, __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 __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_71, __v_31]; 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_71, __v_31]; 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_72: G = __r_arr[0]; let __v_73: G = G::from_u64(3); let __v_74: G = G::from_u64(0); let __v_75: G = { let __values: [G; 4] = [__v_73, __v_0, __v_72, __v_74]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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(1); let __v_77: G = (__v_14 + __v_76); - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_75, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_77]; 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_75, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_77]; 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_78: G = __r_arr[0]; - let __ret: [G; OUT_553] = [__v_78]; - record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_554] = [__v_78]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48373,15 +48372,15 @@ fn aiur_fn_553( }) } -const INPUT_SIZE_554: usize = 7; -const IN_554: usize = 7; -const OUT_554: usize = 1; -fn aiur_fn_554( - inp: [G; IN_554], +const INPUT_SIZE_555: usize = 7; +const IN_555: usize = 7; +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]; @@ -48412,8 +48411,8 @@ fn aiur_fn_554( let __v_20: G = __loaded[3]; match __v_17.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_554] = [__v_18]; - record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_555] = [__v_18]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48428,51 +48427,51 @@ fn aiur_fn_554( }) } -const INPUT_SIZE_555: usize = 3; -const IN_555: usize = 3; -const OUT_555: usize = 1; -fn aiur_fn_555( - inp: [G; IN_555], +const INPUT_SIZE_556: usize = 3; +const IN_556: usize = 3; +const OUT_556: usize = 1; +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]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0, __v_1, __v_3, __v_2, __v_2, __v_4]; 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_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_3, __v_2, __v_2, __v_4]; 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 __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0, __v_1, __v_6, __v_2, __v_2, __v_7]; 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_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_6, __v_2, __v_2, __v_7]; 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 __v_8: G = __r_arr[0]; - let __ret: [G; OUT_555] = [__v_8]; - record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_556] = [__v_8]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_555] = [__v_5]; - record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_556] = [__v_5]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_556: usize = 6; -const IN_556: usize = 6; -const OUT_556: usize = 1; -fn aiur_fn_556( - inp: [G; IN_556], +const INPUT_SIZE_557: usize = 6; +const IN_557: usize = 6; +const OUT_557: usize = 1; +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]; @@ -48487,8 +48486,8 @@ fn aiur_fn_556( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_556] = [__v_9]; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_557] = [__v_9]; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -48506,7 +48505,7 @@ fn aiur_fn_556( let __v_19: G = __loaded[10]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_16, __v_11, __v_12, __v_14, __v_15, __v_13, __v_4]; 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_16, __v_11, __v_12, __v_14, __v_15, __v_13, __v_4]; 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_20: G = __r_arr[0]; let __v_21: G = (__v_20 - __v_0); let __v_22: G = G::from_bool((__v_21 == G::ZERO)); @@ -48526,17 +48525,17 @@ fn aiur_fn_556( let __v_24: G = (__v_22 * __v_23); match __v_24.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_556] = [__v_5]; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_557] = [__v_5]; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_25: G = G::from_u64(1); let __v_26: G = (__v_5 + __v_25); - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_26]; 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_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_26]; 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 __v_27: G = __r_arr[0]; - let __ret: [G; OUT_556] = [__v_27]; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_557] = [__v_27]; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48547,10 +48546,10 @@ fn aiur_fn_556( _ => { let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_21]; 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_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_21]; 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 __v_22: G = __r_arr[0]; - let __ret: [G; OUT_556] = [__v_22]; - record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_557] = [__v_22]; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48562,15 +48561,15 @@ fn aiur_fn_556( }) } -const INPUT_SIZE_557: usize = 3; -const IN_557: usize = 3; -const OUT_557: usize = 1; -fn aiur_fn_557( - inp: [G; IN_557], +const INPUT_SIZE_558: usize = 3; +const IN_558: usize = 3; +const OUT_558: usize = 1; +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]; @@ -48584,19 +48583,19 @@ fn aiur_fn_557( 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_557] = [__v_8]; - record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_558] = [__v_8]; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_4, __v_1, __v_2]; 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_4, __v_1, __v_2]; 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 = __r_arr[0]; - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_5, __v_1, __v_2]; 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_558] = { let __args: [G; IN_558] = [__v_5, __v_1, __v_2]; 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 = __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_557] = [__v_9]; - record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_558] = [__v_9]; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48606,15 +48605,15 @@ fn aiur_fn_557( }) } -const INPUT_SIZE_558: usize = 2; -const IN_558: usize = 2; -const OUT_558: usize = 1; -fn aiur_fn_558( - inp: [G; IN_558], +const INPUT_SIZE_559: usize = 2; +const IN_559: usize = 2; +const OUT_559: usize = 1; +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]; @@ -48628,7 +48627,7 @@ fn aiur_fn_558( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -48644,8 +48643,8 @@ fn aiur_fn_558( let __v_18: G = __loaded[10]; match __v_8.as_canonical_u64() { 6u64 => { - let __ret: [G; OUT_558] = [__v_11]; - record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_559] = [__v_11]; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48662,15 +48661,15 @@ fn aiur_fn_558( }) } -const INPUT_SIZE_559: usize = 3; -const IN_559: usize = 3; -const OUT_559: usize = 1; -fn aiur_fn_559( - inp: [G; IN_559], +const INPUT_SIZE_560: usize = 3; +const IN_560: usize = 3; +const OUT_560: usize = 1; +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]; @@ -48684,8 +48683,8 @@ fn aiur_fn_559( 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_559] = [__v_8]; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_560] = [__v_8]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -48694,11 +48693,11 @@ fn aiur_fn_559( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_5, __v_1, __v_9]; 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_560] = { let __args: [G; IN_560] = [__v_5, __v_1, __v_9]; 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_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_6, __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_559] = [__v_11]; - record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_560] = [__v_11]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48708,15 +48707,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]; @@ -48738,8 +48737,8 @@ fn aiur_fn_560( let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { - 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); }, _ => { @@ -48775,9 +48774,9 @@ fn aiur_fn_560( if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); } - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_8, __v_13, __v_2, __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_8, __v_13, __v_2, __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); }, } @@ -48796,15 +48795,15 @@ fn aiur_fn_560( }) } -const INPUT_SIZE_561: usize = 13; -const IN_561: usize = 13; -const OUT_561: usize = 0; -fn aiur_fn_561( - inp: [G; IN_561], +const INPUT_SIZE_562: usize = 13; +const IN_562: usize = 13; +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]; @@ -48821,7 +48820,7 @@ fn aiur_fn_561( let __v_12: G = inp[12]; match __v_1.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_12, __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_729] = { let __args: [G; IN_729] = [__v_12, __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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -48837,13 +48836,13 @@ fn aiur_fn_561( let __v_24: G = __loaded[10]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_19, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_19, __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_25: G = __r_arr[0]; if (__v_25 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_0.as_canonical_u64() }); } - let __ret: [G; OUT_561] = []; - record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_562] = []; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -48858,19 +48857,19 @@ fn aiur_fn_561( }) } -const INPUT_SIZE_562: usize = 2; -const IN_562: usize = 2; -const OUT_562: usize = 1; -fn aiur_fn_562( - inp: [G; IN_562], +const INPUT_SIZE_563: usize = 2; +const IN_563: usize = 2; +const OUT_563: usize = 1; +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]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __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_729] = { let __args: [G; IN_729] = [__v_1, __v_0]; 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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -48886,7 +48885,7 @@ fn aiur_fn_562( let __v_13: G = __loaded[10]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_0, __v_1]; 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]; 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_14: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; @@ -48905,8 +48904,8 @@ fn aiur_fn_562( match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_562] = [__v_24]; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_563] = [__v_24]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -48917,9 +48916,9 @@ fn aiur_fn_562( match __v_26.as_canonical_u64() { 0u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_8, __v_27]; 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_729] = { let __args: [G; IN_729] = [__v_8, __v_27]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_28]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_28]; 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_29: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_29.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_30: G = __loaded[0]; @@ -48936,22 +48935,22 @@ fn aiur_fn_562( match __v_30.as_canonical_u64() { 6u64 => { let __v_41: G = G::from_bool((__v_36 == G::ZERO)); - let __ret: [G; OUT_562] = [__v_41]; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_563] = [__v_41]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_41: G = G::from_u64(0); - let __ret: [G; OUT_562] = [__v_41]; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_563] = [__v_41]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_562] = [__v_27]; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_563] = [__v_27]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -48963,31 +48962,31 @@ fn aiur_fn_562( }, _ => { let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_562] = [__v_18]; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_563] = [__v_18]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_562] = [__v_14]; - record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_563] = [__v_14]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_563: usize = 2; -const IN_563: usize = 2; -const OUT_563: usize = 1; -fn aiur_fn_563( - inp: [G; IN_563], +const INPUT_SIZE_564: usize = 2; +const IN_564: usize = 2; +const OUT_564: usize = 1; +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]; @@ -49011,22 +49010,22 @@ fn aiur_fn_563( match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_563] = [__v_13]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_13]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_13]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_13]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_10]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_10]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49040,14 +49039,14 @@ fn aiur_fn_563( match __v_6.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_563] = [__v_10]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_10]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_10]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_10]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49066,22 +49065,22 @@ fn aiur_fn_563( match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_563] = [__v_13]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_13]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_13]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_13]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_10]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_10]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49094,28 +49093,28 @@ fn aiur_fn_563( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_3, __v_7]; 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_564] = { let __args: [G; IN_564] = [__v_3, __v_7]; 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 __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __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_564] = { let __args: [G; IN_564] = [__v_4, __v_8]; 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 __v_11: G = __r_arr[0]; - let __ret: [G; OUT_563] = [__v_11]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_11]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_11]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_11]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_10]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_10]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49128,28 +49127,28 @@ fn aiur_fn_563( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_3, __v_7]; 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_564] = { let __args: [G; IN_564] = [__v_3, __v_7]; 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 __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __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_564] = { let __args: [G; IN_564] = [__v_4, __v_8]; 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 __v_11: G = __r_arr[0]; - let __ret: [G; OUT_563] = [__v_11]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_11]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_11]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_11]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_10]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_10]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49162,51 +49161,51 @@ fn aiur_fn_563( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_3, __v_7]; 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_564] = { let __args: [G; IN_564] = [__v_3, __v_7]; 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 __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __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_564] = { let __args: [G; IN_564] = [__v_4, __v_8]; 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 __v_11: G = __r_arr[0]; - let __ret: [G; OUT_563] = [__v_11]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_11]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_11]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_11]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_10]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_10]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_563] = [__v_6]; - record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_564] = [__v_6]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_564: usize = 14; -const IN_564: usize = 14; -const OUT_564: usize = 0; -fn aiur_fn_564( - inp: [G; IN_564], +const INPUT_SIZE_565: usize = 14; +const IN_565: usize = 14; +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]; @@ -49224,16 +49223,16 @@ fn aiur_fn_564( let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; 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_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_14, __v_11, __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_14, __v_11, __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_15: G = __r_arr[0]; - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_14, __v_12]; 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_563] = { let __args: [G; IN_563] = [__v_14, __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 __v_16: G = __r_arr[0]; if (__v_9 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); } - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_12, __v_15]; 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_729] = { let __args: [G; IN_729] = [__v_12, __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_17: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; @@ -49247,7 +49246,7 @@ fn aiur_fn_564( let __v_26: G = __loaded[8]; let __v_27: G = __loaded[9]; let __v_28: G = __loaded[10]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_12, __v_14]; 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_729] = { let __args: [G; IN_729] = [__v_12, __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_29: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_29.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_30: G = __loaded[0]; @@ -49265,7 +49264,7 @@ fn aiur_fn_564( 5u64 => { match __v_30.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_12, __v_13]; 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_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_12, __v_13]; 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_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); @@ -49279,7 +49278,7 @@ fn aiur_fn_564( let __v_47: G = (__v_33 + __v_34); let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_32, __v_47]; 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_48: G = __r_arr[0]; - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_48, __v_35, __v_12, __v_13]; 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_48, __v_35, __v_12, __v_13]; 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_49: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_49.as_canonical_u64() { 1u64 => { @@ -49301,50 +49300,50 @@ fn aiur_fn_564( } }; let __v_50: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_15, __v_12]; 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_15, __v_12]; 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_51: G = __r_arr[0]; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_51, __v_49, __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 __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_51, __v_49, __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 __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_52]; 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_52]; 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_53: G = __r_arr[0]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_52, __v_12]; 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_52, __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_55: G = __r_arr[0]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_52, __v_21, __v_19, __v_50, __v_49, __v_21, __v_12]; 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_52, __v_21, __v_19, __v_50, __v_49, __v_21, __v_12]; 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_56: G = __r_arr[0]; let __v_57: G = G::from_u64(0); - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_52, __v_53, __v_55, __v_21, __v_54, __v_19, __v_49, __v_21, __v_12, __v_13, __v_57]; 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 __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_52, __v_53, __v_55, __v_21, __v_54, __v_19, __v_49, __v_21, __v_12, __v_13, __v_57]; 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 __v_58: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_53, __v_14, __v_12, __v_60]; 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_582] = { let __args: [G; IN_582] = [__v_53, __v_14, __v_12, __v_60]; 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_61: G = __r_arr[0]; let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_49, __v_19, __v_62]; 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_49, __v_19, __v_62]; 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_63: G = __r_arr[0]; let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_20, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_64, __v_21]; 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_64, __v_21]; 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_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_53, __v_11, __v_12]; 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_558] = { let __args: [G; IN_558] = [__v_53, __v_11, __v_12]; 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_67: G = __r_arr[0]; let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_53, __v_14, __v_68]; 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] = [__v_53, __v_14, __v_68]; 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_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_52, __v_70]; 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_52, __v_70]; 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_71: G = __r_arr[0]; let __v_72: G = __r_arr[1]; let __v_73: G = __r_arr[2]; let __v_74: G = __r_arr[3]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_14, __v_35, __v_21, __v_54, __v_59, __v_19, __v_49, __v_56, __v_58, __v_65, __v_67, __v_52, __v_53, __v_55, __v_72, __v_73, __v_74, __v_12, __v_13, __v_61]; 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_596] = { let __args: [G; IN_596] = [__v_0, __v_14, __v_35, __v_21, __v_54, __v_59, __v_19, __v_49, __v_56, __v_58, __v_65, __v_67, __v_52, __v_53, __v_55, __v_72, __v_73, __v_74, __v_12, __v_13, __v_61]; 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_75: G = __r_arr[0]; - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_8, __v_75, __v_12, __v_13]; 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_564] = []; - record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_8, __v_75, __v_12, __v_13]; 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_565] = []; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49364,84 +49363,84 @@ fn aiur_fn_564( }) } -const INPUT_SIZE_565: usize = 3; -const IN_565: usize = 3; -const OUT_565: usize = 1; -fn aiur_fn_565( - inp: [G; IN_565], +const INPUT_SIZE_566: usize = 3; +const IN_566: usize = 3; +const OUT_566: usize = 1; +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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_0, __v_1, __v_2]; 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_0, __v_1, __v_2]; 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_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_3, __v_4, __v_0, __v_2]; 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 __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3, __v_4, __v_0, __v_2]; 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_5: G = __r_arr[0]; - let __ret: [G; OUT_565] = [__v_5]; - record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_566] = [__v_5]; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_566: usize = 4; -const IN_566: usize = 4; -const OUT_566: usize = 1; -fn aiur_fn_566( - inp: [G; IN_566], +const INPUT_SIZE_567: usize = 4; +const IN_567: usize = 4; +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_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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_1.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() { 0u64 => { - let __ret: [G; OUT_566] = [__v_0]; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_567] = [__v_0]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_1]; 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_0, __v_1]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; let __v_9: G = __r_arr[3]; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_6, __v_7, __v_8, __v_9, __v_2, __v_3]; 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_6, __v_7, __v_8, __v_9, __v_2, __v_3]; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_10]; 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_10]; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 + __v_12); - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_11, __v_13, __v_2, __v_3]; 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 __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_11, __v_13, __v_2, __v_3]; 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_14: G = __r_arr[0]; - let __ret: [G; OUT_566] = [__v_14]; - record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_567] = [__v_14]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_567: usize = 6; -const IN_567: usize = 6; -const OUT_567: usize = 1; -fn aiur_fn_567( - inp: [G; IN_567], +const INPUT_SIZE_568: usize = 6; +const IN_568: usize = 6; +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]; @@ -49449,7 +49448,7 @@ fn aiur_fn_567( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __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_729] = { let __args: [G; IN_729] = [__v_5, __v_0]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -49465,33 +49464,33 @@ fn aiur_fn_567( let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_12, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_12, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; 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 = __r_arr[0]; - let __ret: [G; OUT_567] = [__v_18]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_18]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 5] = [__v_18, __v_19, __v_19, __v_19, __v_19]; 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_567] = [__v_20]; - record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_568] = [__v_20]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_568: usize = 7; -const IN_568: usize = 7; -const OUT_568: usize = 1; -fn aiur_fn_568( - inp: [G; IN_568], +const INPUT_SIZE_569: usize = 7; +const IN_569: usize = 7; +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]; @@ -49509,12 +49508,12 @@ fn aiur_fn_568( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 5] = [__v_10, __v_11, __v_11, __v_11, __v_11]; 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_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); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_6, __v_8]; 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_729] = { let __args: [G; IN_729] = [__v_6, __v_8]; 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_10: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -49539,28 +49538,28 @@ fn aiur_fn_568( _ => { let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_22, __v_1, __v_3]; 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_588] = { let __args: [G; IN_588] = [__v_22, __v_1, __v_3]; 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_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, } }; let __v_22: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_22, __v_5, __v_6]; 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_586] = { let __args: [G; IN_586] = [__v_22, __v_5, __v_6]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_23, __v_24]; 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_725] = { let __args: [G; IN_725] = [__v_23, __v_24]; 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_25: G = __r_arr[0]; - let __ret: [G; OUT_568] = [__v_25]; - record.function_queries[568].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)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_22: G = __r_arr[0]; - let __ret: [G; OUT_568] = [__v_22]; - record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_569] = [__v_22]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49572,15 +49571,15 @@ fn aiur_fn_568( }) } -const INPUT_SIZE_569: usize = 2; -const IN_569: usize = 2; -const OUT_569: usize = 1; -fn aiur_fn_569( - inp: [G; IN_569], +const INPUT_SIZE_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_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]; @@ -49592,19 +49591,19 @@ fn aiur_fn_569( let __v_6: G = __loaded[4]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_569] = [__v_0]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_570] = [__v_0]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_3]; 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_0, __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_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_6]; 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_6]; 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_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); }, _ => { @@ -49614,12 +49613,12 @@ fn aiur_fn_569( 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_13: G = { let __values: [G; 6] = [__v_8, __v_3, __v_9, __v_4, __v_5, __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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_13]; 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_734] = { let __args: [G; IN_734] = [__v_0, __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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_14, __v_6]; 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_14, __v_6]; 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_15: G = __r_arr[0]; - let __ret: [G; OUT_569] = [__v_15]; - record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_570] = [__v_15]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49631,15 +49630,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]; @@ -49653,8 +49652,8 @@ fn aiur_fn_570( match __v_2.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_570] = [__v_8]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_8]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -49664,15 +49663,15 @@ fn aiur_fn_570( match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_570] = [__v_11]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_11]; + 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_7, __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_7, __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_11: G = __r_arr[0]; - let __ret: [G; OUT_570] = [__v_11]; - record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_571] = [__v_11]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49684,15 +49683,15 @@ fn aiur_fn_570( }) } -const INPUT_SIZE_571: usize = 3; -const IN_571: usize = 3; -const OUT_571: usize = 1; -fn aiur_fn_571( - inp: [G; IN_571], +const INPUT_SIZE_572: usize = 3; +const IN_572: usize = 3; +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]; @@ -49706,12 +49705,12 @@ fn aiur_fn_571( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 6] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_571] = [__v_8]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_8]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __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_729] = { let __args: [G; IN_729] = [__v_2, __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_6: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -49728,18 +49727,18 @@ fn aiur_fn_571( match __v_7.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_1, __v_8, __v_18]; 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_1, __v_8, __v_18]; 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_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 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 __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_5, __v_1, __v_2]; 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_5, __v_1, __v_2]; 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_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 6] = [__v_20, __v_4, __v_21, __v_24, __v_19, __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_571] = [__v_26]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_26]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49751,11 +49750,11 @@ fn aiur_fn_571( 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_571] = { let __args: [G; IN_571] = [__v_5, __v_1, __v_2]; 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_5, __v_1, __v_2]; 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_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 6] = [__v_18, __v_4, __v_19, __v_22, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_571] = [__v_27]; - record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_572] = [__v_27]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49767,15 +49766,15 @@ fn aiur_fn_571( }) } -const INPUT_SIZE_572: usize = 1; -const IN_572: usize = 1; -const OUT_572: usize = 1; -fn aiur_fn_572( - inp: [G; IN_572], +const INPUT_SIZE_573: usize = 1; +const IN_573: usize = 1; +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 __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 }; @@ -49790,17 +49789,17 @@ fn aiur_fn_572( 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_572] = [__v_9]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_9]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_6]; 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_6]; 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_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_7, __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 __ret: [G; OUT_572] = [__v_9]; - record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_573] = [__v_9]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -49810,15 +49809,15 @@ fn aiur_fn_572( }) } -const INPUT_SIZE_573: usize = 2; -const IN_573: usize = 2; -const OUT_573: usize = 4; -fn aiur_fn_573( - inp: [G; IN_573], +const INPUT_SIZE_574: usize = 2; +const IN_574: usize = 2; +const OUT_574: usize = 4; +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]; @@ -49839,27 +49838,27 @@ fn aiur_fn_573( 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_573] = [__v_8, __v_9, __v_12, __v_15]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_574] = [__v_8, __v_9, __v_12, __v_15]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_573] = [__v_3, __v_4, __v_5, __v_6]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_574] = [__v_3, __v_4, __v_5, __v_6]; + record.function_queries[574].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_573] = { let __args: [G; IN_573] = [__v_7, __v_9]; 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_9]; 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_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_573] = [__v_10, __v_11, __v_12, __v_13]; - record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_574] = [__v_10, __v_11, __v_12, __v_13]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49871,15 +49870,15 @@ fn aiur_fn_573( }) } -const INPUT_SIZE_574: usize = 6; -const IN_574: usize = 6; -const OUT_574: usize = 1; -fn aiur_fn_574( - inp: [G; IN_574], +const INPUT_SIZE_575: usize = 6; +const IN_575: usize = 6; +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 __v_1: G = inp[1]; @@ -49890,32 +49889,32 @@ fn aiur_fn_574( match __v_4.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_1, __v_2, __v_6]; 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_1, __v_2, __v_6]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_7]; - record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_7]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __v_5, __v_3]; 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_0, __v_5, __v_3]; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_6]; - record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_575] = [__v_6]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -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]; @@ -49931,12 +49930,12 @@ fn aiur_fn_575( 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 __ret: [G; OUT_575] = [__v_10]; - record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_10]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -49953,21 +49952,21 @@ fn aiur_fn_575( match __v_9.as_canonical_u64() { 5u64 => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_7, __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_7, __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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_12, __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_575] = [__v_22]; - record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_22]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_7, __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_7, __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_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_20, __v_21, __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_575] = [__v_23]; - record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_576] = [__v_23]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -49979,15 +49978,15 @@ fn aiur_fn_575( }) } -const INPUT_SIZE_576: usize = 3; -const IN_576: usize = 3; -const OUT_576: usize = 1; -fn aiur_fn_576( - inp: [G; IN_576], +const INPUT_SIZE_577: usize = 3; +const IN_577: usize = 3; +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]; @@ -50029,24 +50028,24 @@ fn aiur_fn_576( let __v_36: G = __r_arr[0]; match __v_36.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_576] = [__v_0]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_0]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_1, __v_2, __v_2, __v_37]; 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_581] = { let __args: [G; IN_581] = [__v_1, __v_2, __v_2, __v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; match __v_38.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_576] = [__v_39]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_39]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_576] = [__v_0]; - record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_577] = [__v_0]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50058,15 +50057,128 @@ fn aiur_fn_576( }) } -const INPUT_SIZE_577: usize = 4; -const IN_577: usize = 4; -const OUT_577: usize = 2; -fn aiur_fn_577( - inp: [G; IN_577], +const INPUT_SIZE_578: usize = 3; +const IN_578: usize = 3; +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]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __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_3: G = __r_arr[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_578] = [__v_9]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(1); + let __ret: [G; OUT_578] = [__v_9]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_579: usize = 3; +const IN_579: usize = 3; +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_579], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_579] = [__v_6]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_1, __v_2]; 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_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_579] = [__v_7]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_5, __v_1, __v_2]; 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_7: G = __r_arr[0]; + let __ret: [G; OUT_579] = [__v_7]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_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_580], 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_530] = { let __args: [G; IN_530] = [__v_0, __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 __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_2, __v_2, __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_3: G = __r_arr[0]; + let __ret: [G; OUT_580] = [__v_3]; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_581: usize = 4; +const IN_581: usize = 4; +const OUT_581: usize = 2; +fn aiur_fn_581( + inp: [G; IN_581], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; @@ -50080,8 +50192,8 @@ fn aiur_fn_577( 1u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_577] = [__v_7, __v_8]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_581] = [__v_7, __v_8]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -50105,17 +50217,17 @@ fn aiur_fn_577( 0u64 => { let __v_19: G = G::from_u64(1); let __v_20: G = (__v_3 + __v_19); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_0, __v_6, __v_2, __v_20]; 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_581] = { let __args: [G; IN_581] = [__v_0, __v_6, __v_2, __v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_577] = [__v_21, __v_22]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_581] = [__v_21, __v_22]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; 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_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_19]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_19]; 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_20: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -50131,21 +50243,23 @@ fn aiur_fn_577( let __v_31: G = __loaded[10]; match __v_21.as_canonical_u64() { 5u64 => { - match __v_30.as_canonical_u64() { + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_19, __v_2]; 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_32: G = __r_arr[0]; + match __v_32.as_canonical_u64() { 0u64 => { - let __v_32: G = G::from_u64(1); - let __v_33: G = (__v_3 + __v_32); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_0, __v_6, __v_2, __v_33]; 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_34: G = __r_arr[0]; - let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_577] = [__v_34, __v_35]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_33: G = G::from_u64(1); + let __v_34: G = (__v_3 + __v_33); + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_6, __v_2, __v_34]; 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_35: G = __r_arr[0]; + let __v_36: G = __r_arr[1]; + let __ret: [G; OUT_581] = [__v_35, __v_36]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __v_32: G = G::from_u64(1); - let __ret: [G; OUT_577] = [__v_32, __v_19]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_33: G = G::from_u64(1); + let __ret: [G; OUT_581] = [__v_33, __v_19]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50153,11 +50267,11 @@ fn aiur_fn_577( _ => { let __v_32: G = G::from_u64(1); let __v_33: G = (__v_3 + __v_32); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_0, __v_6, __v_2, __v_33]; 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_581] = { let __args: [G; IN_581] = [__v_0, __v_6, __v_2, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_577] = [__v_34, __v_35]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_581] = [__v_34, __v_35]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50170,11 +50284,11 @@ fn aiur_fn_577( _ => { let __v_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_0, __v_6, __v_2, __v_19]; 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_581] = { let __args: [G; IN_581] = [__v_0, __v_6, __v_2, __v_19]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __ret: [G; OUT_577] = [__v_20, __v_21]; - record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_581] = [__v_20, __v_21]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50186,15 +50300,15 @@ fn aiur_fn_577( }) } -const INPUT_SIZE_578: usize = 4; -const IN_578: usize = 4; -const OUT_578: usize = 1; -fn aiur_fn_578( - inp: [G; IN_578], +const INPUT_SIZE_582: usize = 4; +const IN_582: usize = 4; +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_578], 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]; @@ -50206,8 +50320,8 @@ fn aiur_fn_578( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_578] = [__v_3]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_3]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -50215,12 +50329,12 @@ fn aiur_fn_578( let __v_8: G = G::from_bool((__v_7 == G::ZERO)); match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_578] = [__v_3]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_3]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_2, __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_9: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -50239,17 +50353,17 @@ fn aiur_fn_578( let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_21); - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_6, __v_1, __v_2, __v_22]; 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_582] = { let __args: [G; IN_582] = [__v_6, __v_1, __v_2, __v_22]; 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_23: G = __r_arr[0]; - let __ret: [G; OUT_578] = [__v_23]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_23]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_6, __v_1, __v_2, __v_3]; 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_582] = { let __args: [G; IN_582] = [__v_6, __v_1, __v_2, __v_3]; 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_21: G = __r_arr[0]; - let __ret: [G; OUT_578] = [__v_21]; - record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_582] = [__v_21]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50266,19 +50380,19 @@ 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_583: usize = 2; +const IN_583: usize = 2; +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_579], 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]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __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_729] = { let __args: [G; IN_729] = [__v_1, __v_0]; 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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -50327,29 +50441,32 @@ fn aiur_fn_579( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 32] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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 __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_13, __v_46]; 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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10, __v_46]; 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_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 1u64 => { let __v_48: G = G::from_u64(0); - let __ret: [G; OUT_579] = [__v_48]; - record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_583] = [__v_48]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - match __v_12.as_canonical_u64() { + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __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_48: G = __r_arr[0]; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_0, __v_48, __v_1]; 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_49: G = __r_arr[0]; + match __v_49.as_canonical_u64() { 0u64 => { - let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_13, __v_1, __v_48]; 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_49: G = __r_arr[0]; - let __ret: [G; OUT_579] = [__v_49]; - record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_48, __v_48, __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_50: G = __r_arr[0]; + let __ret: [G; OUT_583] = [__v_50]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __v_48: G = G::from_u64(0); - let __ret: [G; OUT_579] = [__v_48]; - record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_50: G = G::from_u64(0); + let __ret: [G; OUT_583] = [__v_50]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50361,106 +50478,28 @@ fn aiur_fn_579( }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_579] = [__v_14]; - record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } - }) -} - -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_580], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_3: G = __loaded[0]; - let __v_4: G = __loaded[1]; - let __v_5: G = __loaded[2]; - match __v_3.as_canonical_u64() { - 1u64 => { - let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_580] = [__v_6]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_583] = [__v_14]; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, - 0u64 => { - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; - let __v_6: G = __loaded[0]; - let __v_7: G = __loaded[1]; - let __v_8: G = __loaded[2]; - let __v_9: G = __loaded[3]; - let __v_10: G = __loaded[4]; - let __v_11: G = __loaded[5]; - let __v_12: G = __loaded[6]; - let __v_13: G = __loaded[7]; - let __v_14: G = __loaded[8]; - let __v_15: G = __loaded[9]; - let __v_16: G = __loaded[10]; - match __v_6.as_canonical_u64() { - 5u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_16, __v_0]; 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_17: G = __r_arr[0]; - let __v_18: G = (__v_17 * __v_15); - match __v_18.as_canonical_u64() { - 0u64 => { - let __v_19: G = G::from_u64(1); - let __v_20: G = (__v_2 + __v_19); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __v_5, __v_20]; 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_21: G = __r_arr[0]; - let __ret: [G; OUT_580] = [__v_21]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - _ => { - let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_580] = [__v_19]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } - }, - _ => { - let __v_17: G = G::from_u64(1); - let __v_18: G = (__v_2 + __v_17); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __v_5, __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_580] = [__v_19]; - record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); - }, } }) } -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_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_581], ExecError> { +) -> Result<[G; OUT_584], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __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_729] = { let __args: [G; IN_729] = [__v_2, __v_0]; 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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -50476,33 +50515,33 @@ fn aiur_fn_581( let __v_14: G = __loaded[10]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_9, __v_7, __v_1, __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_585] = { let __args: [G; IN_585] = [__v_9, __v_7, __v_1, __v_2]; 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_15: G = __r_arr[0]; - let __ret: [G; OUT_581] = [__v_15]; - record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_15]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 5] = [__v_15, __v_16, __v_16, __v_16, __v_16]; 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_581] = [__v_17]; - record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_584] = [__v_17]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_582: usize = 4; -const IN_582: usize = 4; -const OUT_582: usize = 1; -fn aiur_fn_582( - inp: [G; IN_582], +const INPUT_SIZE_585: usize = 4; +const IN_585: usize = 4; +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_582], 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]; @@ -50517,12 +50556,12 @@ fn aiur_fn_582( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 5] = [__v_7, __v_8, __v_8, __v_8, __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_582] = [__v_9]; - record.function_queries[582].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)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_3, __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_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -50540,21 +50579,21 @@ fn aiur_fn_582( 6u64 => { let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_10, __v_1]; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_19, __v_2, __v_3]; 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_586] = { let __args: [G; IN_586] = [__v_19, __v_2, __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_20: G = __r_arr[0]; - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_6, __v_1, __v_2, __v_3]; 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_585] = { let __args: [G; IN_585] = [__v_6, __v_1, __v_2, __v_3]; 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_21: G = __r_arr[0]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_20, __v_21]; 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_725] = { let __args: [G; IN_725] = [__v_20, __v_21]; 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_22: G = __r_arr[0]; - let __ret: [G; OUT_582] = [__v_22]; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_22]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_6, __v_1, __v_2, __v_3]; 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_585] = { let __args: [G; IN_585] = [__v_6, __v_1, __v_2, __v_3]; 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_19: G = __r_arr[0]; - let __ret: [G; OUT_582] = [__v_19]; - record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_585] = [__v_19]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50566,15 +50605,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_586: usize = 3; +const IN_586: usize = 3; +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_583], 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]; @@ -50586,42 +50625,42 @@ fn aiur_fn_583( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __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_587] = { let __args: [G; IN_587] = [__v_4, __v_1, __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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_5, __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_586] = { let __args: [G; IN_586] = [__v_5, __v_1, __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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__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_725] = { let __args: [G; IN_725] = [__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_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_586] = [__v_9]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 5] = [__v_7, __v_8, __v_8, __v_8, __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_583] = [__v_9]; - record.function_queries[583].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); }, } }) } -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_587: usize = 3; +const IN_587: usize = 3; +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_584], 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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0]; 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_0]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; @@ -50641,12 +50680,12 @@ fn aiur_fn_584( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 5] = [__v_12, __v_13, __v_13, __v_13, __v_13]; 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_584] = [__v_14]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_14]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_8]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_8]; 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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -50670,22 +50709,22 @@ fn aiur_fn_584( let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 5] = [__v_26, __v_27, __v_27, __v_27, __v_27]; 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_584] = [__v_28]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_28]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_6, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_6, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_26, __v_1]; 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_26, __v_1]; 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_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 0u64 => { let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 5] = [__v_28, __v_29, __v_29, __v_29, __v_29]; 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_584] = [__v_30]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_30]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -50694,8 +50733,8 @@ fn aiur_fn_584( let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 5] = [__v_29, __v_30, __v_30, __v_30, __v_30]; 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_32: G = { let __values: [G; 5] = [__v_28, __v_8, __v_26, __v_9, __v_31]; 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_584] = [__v_32]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_32]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50712,8 +50751,8 @@ fn aiur_fn_584( let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 5] = [__v_24, __v_25, __v_25, __v_25, __v_25]; 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_584] = [__v_26]; - record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_587] = [__v_26]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50727,45 +50766,45 @@ fn aiur_fn_584( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 5] = [__v_11, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_584] = [__v_13]; - record.function_queries[584].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)); return Ok(__ret); }, } }) } -const INPUT_SIZE_585: usize = 3; -const IN_585: usize = 3; -const OUT_585: usize = 1; -fn aiur_fn_585( - inp: [G; IN_585], +const INPUT_SIZE_588: usize = 3; +const IN_588: usize = 3; +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_585], 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]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_1, __v_2, __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_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3]; 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_4: G = __r_arr[0]; - let __ret: [G; OUT_585] = [__v_4]; - record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_588] = [__v_4]; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_586: usize = 4; -const IN_586: usize = 4; -const OUT_586: usize = 1; -fn aiur_fn_586( - inp: [G; IN_586], +const INPUT_SIZE_589: usize = 4; +const IN_589: usize = 4; +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_586], 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]; @@ -50773,8 +50812,8 @@ fn aiur_fn_586( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_586] = [__v_0]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_0]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50785,7 +50824,7 @@ fn aiur_fn_586( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_2, __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_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_6, __v_8, __v_9]; 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)? } }; @@ -50794,10 +50833,10 @@ fn aiur_fn_586( let __v_12: G = (__v_1 - __v_11); let __v_13: G = G::from_u64(1); let __v_14: G = (__v_3 + __v_13); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_10, __v_12, __v_2, __v_14]; 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_589] = { let __args: [G; IN_589] = [__v_10, __v_12, __v_2, __v_14]; 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_15: G = __r_arr[0]; - let __ret: [G; OUT_586] = [__v_15]; - record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_589] = [__v_15]; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50809,39 +50848,39 @@ fn aiur_fn_586( }) } -const INPUT_SIZE_587: usize = 2; -const IN_587: usize = 2; -const OUT_587: usize = 0; -fn aiur_fn_587( - inp: [G; IN_587], +const INPUT_SIZE_590: usize = 2; +const IN_590: usize = 2; +const OUT_590: usize = 0; +fn aiur_fn_590( + inp: [G; IN_590], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_587], 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 __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __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_592] = { let __args: [G; IN_592] = [__v_0, __v_0, __v_1]; 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_2: G = __r_arr[0]; - 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_591] = { let __args: [G; IN_591] = [__v_0, __v_1]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_2, __v_3, __v_4, __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 __ret: [G; OUT_587] = []; - record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_2, __v_3, __v_4, __v_1]; 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 __ret: [G; OUT_590] = []; + record.function_queries[590].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 = 2; -fn aiur_fn_588( - inp: [G; IN_588], +const INPUT_SIZE_591: usize = 2; +const IN_591: usize = 2; +const OUT_591: usize = 2; +fn aiur_fn_591( + inp: [G; IN_591], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_588], 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]; @@ -50855,24 +50894,24 @@ fn aiur_fn_588( 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_588] = [__v_5, __v_8]; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_5, __v_8]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __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_583] = { let __args: [G; IN_583] = [__v_3, __v_1]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_4, __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_591] = { let __args: [G; IN_591] = [__v_4, __v_1]; 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 __v_7: G = __r_arr[1]; - let __ret: [G; OUT_588] = [__v_6, __v_7]; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_6, __v_7]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_6: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -50888,19 +50927,19 @@ fn aiur_fn_588( let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_9, __v_10]; 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_9, __v_10]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_588] = [__v_10, __v_18]; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_10, __v_18]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_4, __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_591] = { let __args: [G; IN_591] = [__v_4, __v_1]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_588] = [__v_18, __v_19]; - record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_591] = [__v_18, __v_19]; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -50917,15 +50956,15 @@ fn aiur_fn_588( }) } -const INPUT_SIZE_589: usize = 3; -const IN_589: usize = 3; -const OUT_589: usize = 1; -fn aiur_fn_589( - inp: [G; IN_589], +const INPUT_SIZE_592: usize = 3; +const IN_592: usize = 3; +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_589], 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]; @@ -50939,30 +50978,30 @@ fn aiur_fn_589( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 5] = [__v_6, __v_7, __v_7, __v_7, __v_7]; 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_589] = [__v_8]; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_8]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_2]; 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_583] = { let __args: [G; IN_583] = [__v_4, __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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_5, __v_1, __v_2]; 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_592] = { let __args: [G; IN_592] = [__v_5, __v_1, __v_2]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_589] = [__v_7]; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_7]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1, __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_584] = { let __args: [G; IN_584] = [__v_4, __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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_5, __v_1, __v_2]; 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_592] = { let __args: [G; IN_592] = [__v_5, __v_1, __v_2]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__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_725] = { let __args: [G; IN_725] = [__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_9: G = __r_arr[0]; - let __ret: [G; OUT_589] = [__v_9]; - record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_592] = [__v_9]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -50977,15 +51016,15 @@ fn aiur_fn_589( }) } -const INPUT_SIZE_590: usize = 5; -const IN_590: usize = 5; -const OUT_590: usize = 0; -fn aiur_fn_590( - inp: [G; IN_590], +const INPUT_SIZE_593: usize = 5; +const IN_593: usize = 5; +const OUT_593: usize = 0; +fn aiur_fn_593( + inp: [G; IN_593], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_590], 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]; @@ -50998,22 +51037,22 @@ fn aiur_fn_590( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_590] = []; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_593] = []; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_6, __v_4]; 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_583] = { let __args: [G; IN_583] = [__v_6, __v_4]; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2, __v_3, __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 __ret: [G; OUT_590] = []; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_593] = []; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_6]; 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_729] = { let __args: [G; IN_729] = [__v_4, __v_6]; 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_9: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -51029,21 +51068,21 @@ fn aiur_fn_590( let __v_20: G = __loaded[10]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_12, __v_15, __v_1, __v_2, __v_3, __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_594] = { let __args: [G; IN_594] = [__v_12, __v_15, __v_1, __v_2, __v_3, __v_4]; 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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); } - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2, __v_3, __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 __ret: [G; OUT_590] = []; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_593] = []; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2, __v_3, __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 __ret: [G; OUT_590] = []; - record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 __ret: [G; OUT_593] = []; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51060,15 +51099,15 @@ fn aiur_fn_590( }) } -const INPUT_SIZE_591: usize = 6; -const IN_591: usize = 6; -const OUT_591: usize = 1; -fn aiur_fn_591( - inp: [G; IN_591], +const INPUT_SIZE_594: usize = 6; +const IN_594: usize = 6; +const OUT_594: usize = 1; +fn aiur_fn_594( + inp: [G; IN_594], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_591], 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]; @@ -51085,12 +51124,12 @@ fn aiur_fn_591( match __v_6.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_591] = [__v_11]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_11]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_5, __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_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -51106,11 +51145,11 @@ fn aiur_fn_591( let __v_22: G = __loaded[10]; match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_14, __v_15, __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_588] = { let __args: [G; IN_588] = [__v_14, __v_15, __v_8]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_23, __v_4]; 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_23, __v_4]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_24, __v_0]; 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_616] = { let __args: [G; IN_616] = [__v_24, __v_0]; 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_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { @@ -51121,47 +51160,47 @@ fn aiur_fn_591( let __v_28: G = (__v_26 - __v_27); match __v_28.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_17, __v_15, __v_8, __v_4, __v_5]; 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_595] = { let __args: [G; IN_595] = [__v_1, __v_17, __v_15, __v_8, __v_4, __v_5]; 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_29: G = __r_arr[0]; match __v_29.as_canonical_u64() { 1u64 => { let __v_30: G = G::from_u64(1); - let __ret: [G; OUT_591] = [__v_30]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_30]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_594] = { let __args: [G; IN_594] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_30: G = __r_arr[0]; - let __ret: [G; OUT_591] = [__v_30]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_30]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_594] = { let __args: [G; IN_594] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_29: G = __r_arr[0]; - let __ret: [G; OUT_591] = [__v_29]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_29]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_594] = { let __args: [G; IN_594] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_26: G = __r_arr[0]; - let __ret: [G; OUT_591] = [__v_26]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_26]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_594] = { let __args: [G; IN_594] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; 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_23: G = __r_arr[0]; - let __ret: [G; OUT_591] = [__v_23]; - record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_594] = [__v_23]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51173,15 +51212,15 @@ fn aiur_fn_591( }) } -const INPUT_SIZE_592: usize = 6; -const IN_592: usize = 6; -const OUT_592: usize = 1; -fn aiur_fn_592( - inp: [G; IN_592], +const INPUT_SIZE_595: usize = 6; +const IN_595: usize = 6; +const OUT_595: usize = 1; +fn aiur_fn_595( + inp: [G; IN_595], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_592], 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]; @@ -51202,14 +51241,14 @@ fn aiur_fn_592( match __v_9.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_592] = [__v_12]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_12]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_592] = [__v_12]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_12]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51222,12 +51261,12 @@ fn aiur_fn_592( match __v_9.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_592] = [__v_12]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_12]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_7]; 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_729] = { let __args: [G; IN_729] = [__v_5, __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_12: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -51241,7 +51280,7 @@ fn aiur_fn_592( let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; let __v_23: G = __loaded[10]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_5, __v_10]; 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_729] = { let __args: [G; IN_729] = [__v_5, __v_10]; 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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -51259,40 +51298,40 @@ fn aiur_fn_592( 6u64 => { match __v_25.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_27, __v_2, __v_3]; 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_588] = { let __args: [G; IN_588] = [__v_27, __v_2, __v_3]; 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_36: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_36, __v_4]; 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_36, __v_4]; 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_37: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_37, __v_15]; 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_616] = { let __args: [G; IN_616] = [__v_37, __v_15]; 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_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_11, __v_2, __v_3, __v_4, __v_5]; 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_595] = { let __args: [G; IN_595] = [__v_8, __v_11, __v_2, __v_3, __v_4, __v_5]; 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_39: G = __r_arr[0]; - let __ret: [G; OUT_592] = [__v_39]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_39]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_592] = [__v_39]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_39]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_592] = [__v_36]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_36]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_592] = [__v_36]; - record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_595] = [__v_36]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51309,15 +51348,15 @@ fn aiur_fn_592( }) } -const INPUT_SIZE_593: usize = 21; -const IN_593: usize = 21; -const OUT_593: usize = 1; -fn aiur_fn_593( - inp: [G; IN_593], +const INPUT_SIZE_596: usize = 21; +const IN_596: usize = 21; +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_593], 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]; @@ -51349,12 +51388,12 @@ fn aiur_fn_593( let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 5] = [__v_24, __v_25, __v_25, __v_25, __v_25]; 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_593] = [__v_26]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_596] = [__v_26]; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_18, __v_22]; 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_729] = { let __args: [G; IN_729] = [__v_18, __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_24: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -51370,16 +51409,16 @@ fn aiur_fn_593( let __v_35: G = __loaded[10]; match __v_25.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_28, __v_22, __v_27, __v_20, __v_3, __v_4, __v_5, __v_6, __v_7, __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[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_551] = { let __args: [G; IN_551] = [__v_0, __v_28, __v_22, __v_27, __v_20, __v_3, __v_4, __v_5, __v_6, __v_7, __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[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_36: G = __r_arr[0]; let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(1); let __v_39: G = (__v_20 + __v_38); - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_1, __v_23, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_39]; 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_596] = { let __args: [G; IN_596] = [__v_0, __v_1, __v_23, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_39]; 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_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 5] = [__v_37, __v_22, __v_31, __v_36, __v_40]; 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_593] = [__v_41]; - record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_596] = [__v_41]; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51394,15 +51433,15 @@ fn aiur_fn_593( }) } -const INPUT_SIZE_594: usize = 11; -const IN_594: usize = 11; -const OUT_594: usize = 1; -fn aiur_fn_594( - inp: [G; IN_594], +const INPUT_SIZE_597: usize = 11; +const IN_597: usize = 11; +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_594], 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]; @@ -51424,18 +51463,18 @@ fn aiur_fn_594( 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_594] = [__v_16]; - record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_597] = [__v_16]; + record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_10]; 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_729] = { let __args: [G; IN_729] = [__v_1, __v_10]; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_14]; 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_729] = { let __args: [G; IN_729] = [__v_3, __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 = (__v_5 + __v_10); let __v_17: G = (__v_6 + __v_16); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_12]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_12]; 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 __v_19: G = (__v_5 - __v_12); let __v_20: G = (__v_19 + __v_10); @@ -51444,12 +51483,12 @@ fn aiur_fn_594( let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_22, __v_7, __v_8, __v_9]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_23]; 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_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_24]; 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_727] = { let __args: [G; IN_727] = [__v_24]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_26, __v_7]; 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_724] = { let __args: [G; IN_724] = [__v_26, __v_7]; 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_27: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_25, __v_27, __v_8, __v_9]; 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_28: G = __r_arr[0]; @@ -51467,7 +51506,7 @@ fn aiur_fn_594( let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_40, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_40, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); @@ -51478,21 +51517,21 @@ fn aiur_fn_594( let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_46, __v_38, __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_49: G = G::from_u64(0); - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_48, __v_29, __v_49]; 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_48, __v_29, __v_49]; 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_50: G = __r_arr[0]; let __v_51: G = G::from_u64(3); let __v_52: G = G::from_u64(0); let __v_53: G = { let __values: [G; 4] = [__v_51, __v_45, __v_50, __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 __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_53, __v_24]; 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_53, __v_24]; 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_54: G = __r_arr[0]; let __v_55: G = G::from_u64(0); let __v_56: G = G::from_u64(1); let __v_57: G = (__v_10 + __v_56); - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_57]; 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_597] = { let __args: [G; IN_597] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_57]; 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_58: G = __r_arr[0]; let __v_59: G = { let __values: [G; 3] = [__v_55, __v_54, __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_594] = [__v_59]; - record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_597] = [__v_59]; + record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51502,15 +51541,15 @@ fn aiur_fn_594( }) } -const INPUT_SIZE_595: usize = 7; -const IN_595: usize = 7; -const OUT_595: usize = 0; -fn aiur_fn_595( - inp: [G; IN_595], +const INPUT_SIZE_598: usize = 7; +const IN_598: usize = 7; +const OUT_598: usize = 0; +fn aiur_fn_598( + inp: [G; IN_598], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_595], 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]; @@ -51556,15 +51595,15 @@ fn aiur_fn_595( let __v_40: G = __r_arr[0]; match __v_40.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_595] = []; - record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_598] = []; + record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_41: G = G::from_u64(0); - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_6, __v_41]; 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 __ret: [G; OUT_595] = []; - record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_6, __v_41]; 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 __ret: [G; OUT_598] = []; + record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51574,15 +51613,15 @@ fn aiur_fn_595( }) } -const INPUT_SIZE_596: usize = 9; -const IN_596: usize = 9; -const OUT_596: usize = 0; -fn aiur_fn_596( - inp: [G; IN_596], +const INPUT_SIZE_599: usize = 9; +const IN_599: usize = 9; +const OUT_599: usize = 0; +fn aiur_fn_599( + inp: [G; IN_599], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_596], 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]; @@ -51599,8 +51638,8 @@ fn aiur_fn_596( let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_596] = []; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_599] = []; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -51618,7 +51657,7 @@ fn aiur_fn_596( let __v_22: G = __loaded[10]; match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_22, __v_4]; 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 __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_19, __v_4]; 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_23: G = __r_arr[0]; let __v_24: G = (__v_8 - __v_0); let __v_25: G = G::from_bool((__v_24 == G::ZERO)); @@ -51630,7 +51669,7 @@ fn aiur_fn_596( if (__v_15 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); } - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_1, __v_14, __v_2, __v_6, __v_7]; 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_600] = { let __args: [G; IN_600] = [__v_1, __v_14, __v_2, __v_6, __v_7]; 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_29: G = (__v_2 + __v_3); let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1, __v_29]; 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_30: G = __r_arr[0]; @@ -51645,17 +51684,17 @@ fn aiur_fn_596( } let __v_35: G = G::from_u64(1); let __v_36: G = (__v_8 + __v_35); - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_36]; 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 __ret: [G; OUT_596] = []; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_36]; 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 __ret: [G; OUT_599] = []; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_29: G = G::from_u64(1); let __v_30: G = (__v_8 + __v_29); - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_30]; 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 __ret: [G; OUT_596] = []; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_30]; 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 __ret: [G; OUT_599] = []; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51666,9 +51705,9 @@ fn aiur_fn_596( _ => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_8 + __v_23); - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_24]; 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 __ret: [G; OUT_596] = []; - record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_24]; 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 __ret: [G; OUT_599] = []; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -51680,15 +51719,15 @@ fn aiur_fn_596( }) } -const INPUT_SIZE_597: usize = 5; -const IN_597: usize = 5; -const OUT_597: usize = 0; -fn aiur_fn_597( - inp: [G; IN_597], +const INPUT_SIZE_600: usize = 5; +const IN_600: usize = 5; +const OUT_600: usize = 0; +fn aiur_fn_600( + inp: [G; IN_600], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_597], 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]; @@ -51698,22 +51737,22 @@ fn aiur_fn_597( 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_598] = { let __args: [G; IN_598] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; 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 __ret: [G; OUT_597] = []; - record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; 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 __ret: [G; OUT_600] = []; + record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_598: usize = 6; -const IN_598: usize = 6; -const OUT_598: usize = 0; -fn aiur_fn_598( - inp: [G; IN_598], +const INPUT_SIZE_601: usize = 6; +const IN_601: usize = 6; +const OUT_601: usize = 0; +fn aiur_fn_601( + inp: [G; IN_601], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_598], 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]; @@ -51723,8 +51762,8 @@ fn aiur_fn_598( let __v_5: G = inp[5]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_598] = []; - record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_601] = []; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51752,9 +51791,9 @@ fn aiur_fn_598( let __v_17: G = { let __values: [G; 3] = [__v_16, __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_18: G = G::from_u64(1); let __v_19: G = (__v_2 - __v_18); - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_8, __v_12, __v_19, __v_17, __v_4, __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 __ret: [G; OUT_598] = []; - record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_8, __v_12, __v_19, __v_17, __v_4, __v_5]; 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 __ret: [G; OUT_601] = []; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51771,15 +51810,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_602: usize = 2; +const IN_602: usize = 2; +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_599], 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]; @@ -51787,8 +51826,8 @@ fn aiur_fn_599( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_599] = [__v_3]; - record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_602] = [__v_3]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51796,14 +51835,14 @@ fn aiur_fn_599( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_599] = [__v_4]; - record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_602] = [__v_4]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_599] = [__v_4]; - record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_602] = [__v_4]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -51815,132 +51854,132 @@ fn aiur_fn_599( }) } -const INPUT_SIZE_600: usize = 2; -const IN_600: usize = 2; -const OUT_600: usize = 1; -fn aiur_fn_600( - inp: [G; IN_600], +const INPUT_SIZE_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_600], 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]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_600] = [__v_1]; - record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_603] = [__v_1]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_600] = [__v_0]; - record.function_queries[600].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); }, } }) } -const INPUT_SIZE_601: usize = 0; -const IN_601: usize = 0; -const OUT_601: usize = 2; -fn aiur_fn_601( - inp: [G; IN_601], +const INPUT_SIZE_604: usize = 0; +const IN_604: usize = 0; +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_601], ExecError> { +) -> Result<[G; OUT_604], 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_601] = [__v_0, __v_1]; - record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_604] = [__v_0, __v_1]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_602: usize = 0; -const IN_602: usize = 0; -const OUT_602: usize = 2; -fn aiur_fn_602( - inp: [G; IN_602], +const INPUT_SIZE_605: usize = 0; +const IN_605: usize = 0; +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_602], ExecError> { +) -> Result<[G; OUT_605], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_602] = [__v_0, __v_1]; - record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_605] = [__v_0, __v_1]; + record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_603: usize = 0; -const IN_603: usize = 0; -const OUT_603: usize = 2; -fn aiur_fn_603( - inp: [G; IN_603], +const INPUT_SIZE_606: usize = 0; +const IN_606: usize = 0; +const OUT_606: usize = 2; +fn aiur_fn_606( + inp: [G; IN_606], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_603], ExecError> { +) -> Result<[G; OUT_606], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(1); let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_603] = [__v_0, __v_1]; - record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_606] = [__v_0, __v_1]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_604: usize = 0; -const IN_604: usize = 0; -const OUT_604: usize = 2; -fn aiur_fn_604( - inp: [G; IN_604], +const INPUT_SIZE_607: usize = 0; +const IN_607: usize = 0; +const OUT_607: usize = 2; +fn aiur_fn_607( + inp: [G; IN_607], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_604], ExecError> { +) -> Result<[G; OUT_607], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(1); let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_604] = [__v_0, __v_1]; - record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_607] = [__v_0, __v_1]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_605: usize = 0; -const IN_605: usize = 0; -const OUT_605: usize = 2; -fn aiur_fn_605( - inp: [G; IN_605], +const INPUT_SIZE_608: usize = 0; +const IN_608: usize = 0; +const OUT_608: usize = 2; +fn aiur_fn_608( + inp: [G; IN_608], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_605], ExecError> { +) -> Result<[G; OUT_608], 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_605] = [__v_0, __v_1]; - record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_608] = [__v_0, __v_1]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_606: usize = 4; -const IN_606: usize = 4; -const OUT_606: usize = 2; -fn aiur_fn_606( - inp: [G; IN_606], +const INPUT_SIZE_609: usize = 4; +const IN_609: usize = 4; +const OUT_609: usize = 2; +fn aiur_fn_609( + inp: [G; IN_609], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_606], 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]; @@ -51949,46 +51988,46 @@ fn aiur_fn_606( match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); - let __ret: [G; OUT_606] = [__v_2, __v_4]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_609] = [__v_2, __v_4]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_606] = [__v_0, __v_1]; - record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_609] = [__v_0, __v_1]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_607: usize = 1; -const IN_607: usize = 1; -const OUT_607: usize = 2; -fn aiur_fn_607( - inp: [G; IN_607], +const INPUT_SIZE_610: usize = 1; +const IN_610: usize = 1; +const OUT_610: usize = 2; +fn aiur_fn_610( + inp: [G; IN_610], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_607], ExecError> { +) -> Result<[G; OUT_610], 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_607] = [__v_0, __v_1]; - record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_610] = [__v_0, __v_1]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); 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_611: usize = 3; +const IN_611: usize = 3; +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_608], 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]; @@ -52000,8 +52039,8 @@ fn aiur_fn_608( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_608] = [__v_6]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_611] = [__v_6]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -52010,17 +52049,17 @@ fn aiur_fn_608( 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_2); - let __ret: [G; OUT_608] = [__v_8]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_611] = [__v_8]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_5, __v_8]; 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_611] = { let __args: [G; IN_611] = [__v_0, __v_5, __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_608] = [__v_9]; - record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_611] = [__v_9]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52032,44 +52071,44 @@ fn aiur_fn_608( }) } -const INPUT_SIZE_609: usize = 3; -const IN_609: usize = 3; -const OUT_609: usize = 2; -fn aiur_fn_609( - inp: [G; IN_609], +const INPUT_SIZE_612: usize = 3; +const IN_612: usize = 3; +const OUT_612: usize = 2; +fn aiur_fn_612( + inp: [G; IN_612], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_609], ExecError> { +) -> Result<[G; OUT_612], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_2, __v_3]; 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_611] = { let __args: [G; IN_611] = [__v_0, __v_2, __v_3]; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_2, __v_5]; 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_611] = { let __args: [G; IN_611] = [__v_1, __v_2, __v_5]; 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]; match __v_4.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_1]; 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_602] = { let __args: [G; IN_602] = [__v_0, __v_1]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_7]; 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_610] = { let __args: [G; IN_610] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_609] = [__v_8, __v_9]; - record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_612] = [__v_8, __v_9]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_609] = [__v_7, __v_8]; - record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_612] = [__v_7, __v_8]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52077,19 +52116,19 @@ fn aiur_fn_609( _ => { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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_604] = { let __args: [G; IN_604] = []; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_609] = [__v_7, __v_8]; - record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_612] = [__v_7, __v_8]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_6]; 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_602] = { let __args: [G; IN_602] = [__v_4, __v_6]; 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_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_609] = [__v_7, __v_8]; - record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_612] = [__v_7, __v_8]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52098,15 +52137,15 @@ fn aiur_fn_609( }) } -const INPUT_SIZE_610: usize = 2; -const IN_610: usize = 2; -const OUT_610: usize = 1; -fn aiur_fn_610( - inp: [G; IN_610], +const INPUT_SIZE_613: usize = 2; +const IN_613: usize = 2; +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_610], 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]; @@ -52123,14 +52162,14 @@ fn aiur_fn_610( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52143,21 +52182,21 @@ fn aiur_fn_610( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_3, __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_613] = { let __args: [G; IN_613] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52170,31 +52209,31 @@ fn aiur_fn_610( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_3, __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_613] = { let __args: [G; IN_613] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_4, __v_7]; 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_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_603] = { let __args: [G; IN_603] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_610] = [__v_10]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_10]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52207,37 +52246,37 @@ fn aiur_fn_610( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_3, __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_613] = { let __args: [G; IN_613] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_4, __v_7]; 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_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_603] = { let __args: [G; IN_603] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_610] = [__v_10]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_10]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52252,16 +52291,16 @@ fn aiur_fn_610( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_6]; 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_602] = { let __args: [G; IN_602] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_610] = [__v_8]; - record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_613] = [__v_8]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52273,15 +52312,15 @@ fn aiur_fn_610( }) } -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_614: usize = 2; +const IN_614: usize = 2; +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_611], 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]; @@ -52298,14 +52337,14 @@ fn aiur_fn_611( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_611] = [__v_8]; - record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_611] = [__v_8]; - record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52318,19 +52357,19 @@ fn aiur_fn_611( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_611] = [__v_8]; - record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_3, __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_613] = { let __args: [G; IN_613] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_4, __v_7]; 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_614] = { let __args: [G; IN_614] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_603] = { let __args: [G; IN_603] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_611] = [__v_10]; - record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_614] = [__v_10]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52345,38 +52384,38 @@ fn aiur_fn_611( }) } -const INPUT_SIZE_612: usize = 2; -const IN_612: usize = 2; -const OUT_612: usize = 2; -fn aiur_fn_612( - inp: [G; IN_612], +const INPUT_SIZE_615: usize = 2; +const IN_615: usize = 2; +const OUT_615: usize = 2; +fn aiur_fn_615( + inp: [G; IN_615], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_612], ExecError> { +) -> Result<[G; OUT_615], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0, __v_1]; 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_614] = { let __args: [G; IN_614] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2]; 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_610] = { let __args: [G; IN_610] = [__v_2]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_612] = [__v_3, __v_4]; - record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_615] = [__v_3, __v_4]; + record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_613: usize = 2; -const IN_613: usize = 2; -const OUT_613: usize = 1; -fn aiur_fn_613( - inp: [G; IN_613], +const INPUT_SIZE_616: usize = 2; +const IN_616: usize = 2; +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_613], 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]; @@ -52384,8 +52423,8 @@ fn aiur_fn_613( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_613] = [__v_3]; - record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_3]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52399,25 +52438,25 @@ fn aiur_fn_613( let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__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[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_617] = { let __args: [G; IN_617] = [__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[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_11: G = __r_arr[0]; - let __ret: [G; OUT_613] = [__v_11]; - record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_616] = [__v_11]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_614: usize = 8; -const IN_614: usize = 8; -const OUT_614: usize = 1; -fn aiur_fn_614( - inp: [G; IN_614], +const INPUT_SIZE_617: usize = 8; +const IN_617: usize = 8; +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_614], 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]; @@ -52431,16 +52470,16 @@ fn aiur_fn_614( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __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_602] = { let __args: [G; IN_602] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52449,21 +52488,21 @@ fn aiur_fn_614( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_5]; 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_613] = { let __args: [G; IN_613] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52472,31 +52511,31 @@ fn aiur_fn_614( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __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_602] = { let __args: [G; IN_602] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__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_614] = { let __args: [G; IN_614] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_603] = { let __args: [G; IN_603] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_10]; - record.function_queries[614].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); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52505,37 +52544,37 @@ fn aiur_fn_614( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_1, __v_5]; 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_616] = { let __args: [G; IN_616] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_6]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_603] = { let __args: [G; IN_603] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_10]; - record.function_queries[614].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); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52544,43 +52583,43 @@ fn aiur_fn_614( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_1, __v_5]; 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_616] = { let __args: [G; IN_616] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_6]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_603] = { let __args: [G; IN_603] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_10]; - record.function_queries[614].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); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52589,49 +52628,49 @@ fn aiur_fn_614( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_1, __v_5]; 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_616] = { let __args: [G; IN_616] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_6]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_603] = { let __args: [G; IN_603] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_10]; - record.function_queries[614].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); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52640,59 +52679,59 @@ fn aiur_fn_614( match __v_4.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_1, __v_5]; 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_616] = { let __args: [G; IN_616] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_6]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_3, __v_7]; 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_616] = { let __args: [G; IN_616] = [__v_3, __v_7]; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9, __v_10]; 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_603] = { let __args: [G; IN_603] = [__v_9, __v_10]; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_11]; 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_603] = { let __args: [G; IN_603] = [__v_8, __v_11]; 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_12: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_12]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_12]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52701,21 +52740,21 @@ fn aiur_fn_614( match __v_4.as_canonical_u64() { 8u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_1, __v_2, __v_5, __v_6]; 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_620] = { let __args: [G; IN_620] = [__v_1, __v_2, __v_5, __v_6]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52723,24 +52762,24 @@ fn aiur_fn_614( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __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_602] = { let __args: [G; IN_602] = [__v_1, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_6]; 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_602] = { let __args: [G; IN_602] = [__v_2, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_3, __v_7]; 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_616] = { let __args: [G; IN_616] = [__v_3, __v_7]; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9, __v_10]; 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_603] = { let __args: [G; IN_603] = [__v_9, __v_10]; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_11]; 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_603] = { let __args: [G; IN_603] = [__v_8, __v_11]; 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_12: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_12]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_12]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_614] = [__v_8]; - record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_617] = [__v_8]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52752,15 +52791,15 @@ fn aiur_fn_614( }) } -const INPUT_SIZE_615: usize = 3; -const IN_615: usize = 3; -const OUT_615: usize = 2; -fn aiur_fn_615( - inp: [G; IN_615], +const INPUT_SIZE_618: usize = 3; +const IN_618: usize = 3; +const OUT_618: usize = 2; +fn aiur_fn_618( + inp: [G; IN_618], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_615], 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]; @@ -52768,11 +52807,11 @@ fn aiur_fn_615( let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = []; 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_606] = { let __args: [G; IN_606] = []; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_615] = [__v_4, __v_5]; - record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_618] = [__v_4, __v_5]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -52786,26 +52825,26 @@ fn aiur_fn_615( let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__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[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_619] = { let __args: [G; IN_619] = [__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[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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_615] = [__v_12, __v_13]; - record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_618] = [__v_12, __v_13]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_616: usize = 9; -const IN_616: usize = 9; -const OUT_616: usize = 2; -fn aiur_fn_616( - inp: [G; IN_616], +const INPUT_SIZE_619: usize = 9; +const IN_619: usize = 9; +const OUT_619: usize = 2; +fn aiur_fn_619( + inp: [G; IN_619], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_616], 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]; @@ -52820,21 +52859,21 @@ fn aiur_fn_616( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __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_602] = { let __args: [G; IN_602] = [__v_1, __v_5]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9]; 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_610] = { let __args: [G; IN_610] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_10, __v_11]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_10, __v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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_604] = { let __args: [G; IN_604] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52842,29 +52881,29 @@ fn aiur_fn_616( 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_5]; 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_613] = { let __args: [G; IN_613] = [__v_1, __v_5]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9]; 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_610] = { let __args: [G; IN_610] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_10, __v_11]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_10, __v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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_604] = { let __args: [G; IN_604] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52872,41 +52911,41 @@ fn aiur_fn_616( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_2, __v_6]; 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_615] = { let __args: [G; IN_615] = [__v_2, __v_6]; 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 __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_1, __v_5, __v_8]; 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_612] = { let __args: [G; IN_612] = [__v_1, __v_5, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_11, __v_12]; 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_609] = { let __args: [G; IN_609] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_13, __v_14]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_13, __v_14]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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_604] = { let __args: [G; IN_604] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52914,49 +52953,49 @@ fn aiur_fn_616( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_1, __v_5, __v_8]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_6, __v_8]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_11, __v_12]; 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_609] = { let __args: [G; IN_609] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_13, __v_14]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_13, __v_14]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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_604] = { let __args: [G; IN_604] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -52964,57 +53003,57 @@ fn aiur_fn_616( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_1, __v_5, __v_8]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_6, __v_8]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_11, __v_12]; 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_609] = { let __args: [G; IN_609] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_13, __v_14]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_13, __v_14]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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_604] = { let __args: [G; IN_604] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53022,65 +53061,65 @@ fn aiur_fn_616( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_1, __v_5, __v_8]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_6, __v_8]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_11, __v_12]; 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_609] = { let __args: [G; IN_609] = [__v_9, __v_10, __v_11, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_13, __v_14]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_13, __v_14]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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_604] = { let __args: [G; IN_604] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53088,79 +53127,79 @@ fn aiur_fn_616( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_1, __v_5, __v_8]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_6, __v_8]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_6, __v_8]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_3, __v_7, __v_8]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_3, __v_7, __v_8]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_11, __v_12, __v_13, __v_14]; 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_609] = { let __args: [G; IN_609] = [__v_11, __v_12, __v_13, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_15, __v_16]; 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_609] = { let __args: [G; IN_609] = [__v_9, __v_10, __v_15, __v_16]; 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 __v_18: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_17, __v_18]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_17, __v_18]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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_604] = { let __args: [G; IN_604] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53168,29 +53207,29 @@ fn aiur_fn_616( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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_604] = { let __args: [G; IN_604] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_1, __v_2, __v_5, __v_6]; 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_620] = { let __args: [G; IN_620] = [__v_1, __v_2, __v_5, __v_6]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9]; 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_610] = { let __args: [G; IN_610] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_10, __v_11]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_10, __v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53198,33 +53237,33 @@ fn aiur_fn_616( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_1, __v_5, __v_8]; 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_612] = { let __args: [G; IN_612] = [__v_1, __v_5, __v_8]; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_6]; 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_602] = { let __args: [G; IN_602] = [__v_2, __v_6]; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_11]; 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_610] = { let __args: [G; IN_610] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_3, __v_7, __v_8]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_3, __v_7, __v_8]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_12, __v_13, __v_14, __v_15]; 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_609] = { let __args: [G; IN_609] = [__v_12, __v_13, __v_14, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_9, __v_10, __v_16, __v_17]; 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_609] = { let __args: [G; IN_609] = [__v_9, __v_10, __v_16, __v_17]; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_18, __v_19]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_18, __v_19]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_616] = [__v_9, __v_10]; - record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_619] = [__v_9, __v_10]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53236,15 +53275,15 @@ fn aiur_fn_616( }) } -const INPUT_SIZE_617: usize = 4; -const IN_617: usize = 4; -const OUT_617: usize = 1; -fn aiur_fn_617( - inp: [G; IN_617], +const INPUT_SIZE_620: usize = 4; +const IN_620: usize = 4; +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_617], 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]; @@ -53254,16 +53293,16 @@ fn aiur_fn_617( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_1, __v_3]; 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_621] = { let __args: [G; IN_621] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; - let __ret: [G; OUT_617] = [__v_4]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_620] = [__v_4]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { 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_620] = [__v_4]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53275,15 +53314,15 @@ fn aiur_fn_617( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_617] = [__v_4]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_620] = [__v_4]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_1, __v_3]; 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_624] = { let __args: [G; IN_624] = [__v_1, __v_3]; 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_4: G = __r_arr[0]; - let __ret: [G; OUT_617] = [__v_4]; - record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_620] = [__v_4]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53298,15 +53337,15 @@ fn aiur_fn_617( }) } -const INPUT_SIZE_618: usize = 2; -const IN_618: usize = 2; -const OUT_618: usize = 1; -fn aiur_fn_618( - inp: [G; IN_618], +const INPUT_SIZE_621: usize = 2; +const IN_621: usize = 2; +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_618], 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]; @@ -53314,38 +53353,38 @@ fn aiur_fn_618( let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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_731] = { let __args: [G; IN_731] = [__v_2]; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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_731] = { let __args: [G; IN_731] = [__v_3]; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __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_602] = { let __args: [G; IN_602] = [__v_4, __v_5]; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_3]; 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_622] = { let __args: [G; IN_622] = [__v_2, __v_3]; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_618] = [__v_7]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_621] = [__v_7]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_618] = [__v_6]; - record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_621] = [__v_6]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_619: usize = 2; -const IN_619: usize = 2; -const OUT_619: usize = 1; -fn aiur_fn_619( - inp: [G; IN_619], +const INPUT_SIZE_622: usize = 2; +const IN_622: usize = 2; +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_619], 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]; @@ -53363,8 +53402,8 @@ fn aiur_fn_619( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_619] = [__v_12]; - record.function_queries[619].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); }, 0u64 => { @@ -53381,14 +53420,14 @@ fn aiur_fn_619( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_21]; 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_622] = { let __args: [G; IN_622] = [__v_11, __v_21]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__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[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_623] = { let __args: [G; IN_623] = [__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[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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_22, __v_23]; 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_603] = { let __args: [G; IN_603] = [__v_22, __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_24: G = __r_arr[0]; - let __ret: [G; OUT_619] = [__v_24]; - record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_622] = [__v_24]; + record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53403,15 +53442,15 @@ fn aiur_fn_619( }) } -const INPUT_SIZE_620: usize = 16; -const IN_620: usize = 16; -const OUT_620: usize = 1; -fn aiur_fn_620( - inp: [G; IN_620], +const INPUT_SIZE_623: usize = 16; +const IN_623: usize = 16; +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_620], 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]; @@ -53429,51 +53468,51 @@ fn aiur_fn_620( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7, __v_15]; 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_602] = { let __args: [G; IN_602] = [__v_7, __v_15]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_14]; 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_602] = { let __args: [G; IN_602] = [__v_6, __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_17: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_5, __v_13]; 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_602] = { let __args: [G; IN_602] = [__v_5, __v_13]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_4, __v_12]; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_11]; 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_602] = { let __args: [G; IN_602] = [__v_3, __v_11]; 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_20: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_10]; 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_602] = { let __args: [G; IN_602] = [__v_2, __v_10]; 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_21: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_9]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_9]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __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_602] = { let __args: [G; IN_602] = [__v_0, __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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_22, __v_23]; 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_603] = { let __args: [G; IN_603] = [__v_22, __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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_21, __v_24]; 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_603] = { let __args: [G; IN_603] = [__v_21, __v_24]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_20, __v_25]; 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_603] = { let __args: [G; IN_603] = [__v_20, __v_25]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_19, __v_26]; 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_603] = { let __args: [G; IN_603] = [__v_19, __v_26]; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_18, __v_27]; 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_603] = { let __args: [G; IN_603] = [__v_18, __v_27]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_17, __v_28]; 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_603] = { let __args: [G; IN_603] = [__v_17, __v_28]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_16, __v_29]; 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_603] = { let __args: [G; IN_603] = [__v_16, __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_30: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_30]; - record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_623] = [__v_30]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_621: usize = 2; -const IN_621: usize = 2; -const OUT_621: usize = 1; -fn aiur_fn_621( - inp: [G; IN_621], +const INPUT_SIZE_624: usize = 2; +const IN_624: usize = 2; +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_621], 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]; @@ -53490,14 +53529,14 @@ fn aiur_fn_621( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_621] = [__v_8]; - record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_624] = [__v_8]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_621] = [__v_8]; - record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_624] = [__v_8]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53510,19 +53549,19 @@ fn aiur_fn_621( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_621] = [__v_8]; - record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_624] = [__v_8]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_6]; 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_602] = { let __args: [G; IN_602] = [__v_3, __v_6]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_4, __v_7]; 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_624] = { let __args: [G; IN_624] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_9]; 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_603] = { let __args: [G; IN_603] = [__v_8, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_621] = [__v_10]; - record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_624] = [__v_10]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53537,15 +53576,15 @@ fn aiur_fn_621( }) } -const INPUT_SIZE_622: usize = 6; -const IN_622: usize = 6; -const OUT_622: usize = 1; -fn aiur_fn_622( - inp: [G; IN_622], +const INPUT_SIZE_625: usize = 6; +const IN_625: usize = 6; +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_622], 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]; @@ -53557,18 +53596,18 @@ fn aiur_fn_622( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __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_602] = { let __args: [G; IN_602] = [__v_0, __v_3]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_4]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_4]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_5]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_5]; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7, __v_8]; 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_603] = { let __args: [G; IN_603] = [__v_7, __v_8]; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_6, __v_9]; 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_603] = { let __args: [G; IN_603] = [__v_6, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_622] = [__v_10]; - record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_625] = [__v_10]; + record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53577,15 +53616,15 @@ fn aiur_fn_622( }) } -const INPUT_SIZE_623: usize = 2; -const IN_623: usize = 2; -const OUT_623: usize = 1; -fn aiur_fn_623( - inp: [G; IN_623], +const INPUT_SIZE_626: usize = 2; +const IN_626: usize = 2; +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_623], 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]; @@ -53606,14 +53645,14 @@ fn aiur_fn_623( match __v_7.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_623] = [__v_12]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_12]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_623] = [__v_12]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_12]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53628,19 +53667,19 @@ fn aiur_fn_623( match __v_7.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(2); - let __ret: [G; OUT_623] = [__v_12]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_12]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; 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_625] = { let __args: [G; IN_625] = [__v_3, __v_4, __v_5, __v_8, __v_9, __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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_6, __v_11]; 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_626] = { let __args: [G; IN_626] = [__v_6, __v_11]; 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_13: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_12, __v_13]; 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_603] = { let __args: [G; IN_603] = [__v_12, __v_13]; 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_14: G = __r_arr[0]; - let __ret: [G; OUT_623] = [__v_14]; - record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_626] = [__v_14]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53655,15 +53694,15 @@ fn aiur_fn_623( }) } -const INPUT_SIZE_624: usize = 7; -const IN_624: usize = 7; -const OUT_624: usize = 2; -fn aiur_fn_624( - inp: [G; IN_624], +const INPUT_SIZE_627: usize = 7; +const IN_627: usize = 7; +const OUT_627: usize = 2; +fn aiur_fn_627( + inp: [G; IN_627], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_624], 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]; @@ -53676,27 +53715,27 @@ fn aiur_fn_624( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __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_602] = { let __args: [G; IN_602] = [__v_0, __v_3]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_7]; 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_610] = { let __args: [G; IN_610] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_4]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_4]; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_10]; 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_610] = { let __args: [G; IN_610] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_5, __v_6]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_5, __v_6]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_11, __v_12, __v_13, __v_14]; 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_609] = { let __args: [G; IN_609] = [__v_11, __v_12, __v_13, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_8, __v_9, __v_15, __v_16]; 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_609] = { let __args: [G; IN_609] = [__v_8, __v_9, __v_15, __v_16]; 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 __v_18: G = __r_arr[1]; - let __ret: [G; OUT_624] = [__v_17, __v_18]; - record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_627] = [__v_17, __v_18]; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53705,15 +53744,15 @@ fn aiur_fn_624( }) } -const INPUT_SIZE_625: usize = 3; -const IN_625: usize = 3; -const OUT_625: usize = 2; -fn aiur_fn_625( - inp: [G; IN_625], +const INPUT_SIZE_628: usize = 3; +const IN_628: usize = 3; +const OUT_628: usize = 2; +fn aiur_fn_628( + inp: [G; IN_628], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_625], 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]; @@ -53734,19 +53773,19 @@ fn aiur_fn_625( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = []; 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_606] = { let __args: [G; IN_606] = []; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_625] = [__v_13, __v_14]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_13, __v_14]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = []; 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_604] = { let __args: [G; IN_604] = []; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_625] = [__v_13, __v_14]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_13, __v_14]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -53760,25 +53799,25 @@ fn aiur_fn_625( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = []; 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_608] = { let __args: [G; IN_608] = []; 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 __v_14: G = __r_arr[1]; - let __ret: [G; OUT_625] = [__v_13, __v_14]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_13, __v_14]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; 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_627] = { let __args: [G; IN_627] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_7, __v_12, __v_2]; 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_628] = { let __args: [G; IN_628] = [__v_7, __v_12, __v_2]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_13, __v_14, __v_15, __v_16]; 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_609] = { let __args: [G; IN_609] = [__v_13, __v_14, __v_15, __v_16]; 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 __v_18: G = __r_arr[1]; - let __ret: [G; OUT_625] = [__v_17, __v_18]; - record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_628] = [__v_17, __v_18]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53793,15 +53832,15 @@ fn aiur_fn_625( }) } -const INPUT_SIZE_626: usize = 11; -const IN_626: usize = 11; -const OUT_626: usize = 1; -fn aiur_fn_626( - inp: [G; IN_626], +const INPUT_SIZE_629: usize = 11; +const IN_629: usize = 11; +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_626], 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]; @@ -53817,50 +53856,50 @@ fn aiur_fn_626( match __v_0.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_626] = [__v_11]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_11]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_626] = [__v_11]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_11]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_626] = [__v_11]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_11]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_626] = [__v_11]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_11]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_11: G = G::from_u64(2); - let __ret: [G; OUT_626] = [__v_11]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_11]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_11: G = G::from_u64(3); - let __ret: [G; OUT_626] = [__v_11]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_11]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(4); - let __ret: [G; OUT_626] = [__v_11]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_11]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_11: G = G::from_u64(5); - let __ret: [G; OUT_626] = [__v_11]; - record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_629] = [__v_11]; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -53870,15 +53909,15 @@ fn aiur_fn_626( }) } -const INPUT_SIZE_627: usize = 22; -const IN_627: usize = 22; -const OUT_627: usize = 1; -fn aiur_fn_627( - inp: [G; IN_627], +const INPUT_SIZE_630: usize = 22; +const IN_630: usize = 22; +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_627], 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]; @@ -53902,38 +53941,38 @@ fn aiur_fn_627( let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; - 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]; 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_629] = { let __args: [G; IN_629] = [__v_0, __v_1, __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[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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_11, __v_12, __v_13, __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[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_629] = { let __args: [G; IN_629] = [__v_11, __v_12, __v_13, __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[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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_22, __v_23]; 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_602] = { let __args: [G; IN_602] = [__v_22, __v_23]; 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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __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[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_631] = { let __args: [G; IN_631] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __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[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_25: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_25]; - record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_25]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_627] = [__v_24]; - record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_630] = [__v_24]; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_628: usize = 22; -const IN_628: usize = 22; -const OUT_628: usize = 1; -fn aiur_fn_628( - inp: [G; IN_628], +const INPUT_SIZE_631: usize = 22; +const IN_631: usize = 22; +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_628], 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]; @@ -53961,18 +54000,18 @@ fn aiur_fn_628( 1u64 => { match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_13]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_3, __v_14]; 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_616] = { let __args: [G; IN_616] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23, __v_24]; 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_603] = { let __args: [G; IN_603] = [__v_23, __v_24]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_22, __v_25]; 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_603] = { let __args: [G; IN_603] = [__v_22, __v_25]; 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_26: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_26]; - record.function_queries[628].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)); return Ok(__ret); }, _ => { @@ -53983,18 +54022,18 @@ fn aiur_fn_628( 2u64 => { match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_13]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_3, __v_14]; 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_616] = { let __args: [G; IN_616] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23, __v_24]; 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_603] = { let __args: [G; IN_603] = [__v_23, __v_24]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_22, __v_25]; 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_603] = { let __args: [G; IN_603] = [__v_22, __v_25]; 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_26: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_26]; - record.function_queries[628].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)); return Ok(__ret); }, _ => { @@ -54005,22 +54044,22 @@ fn aiur_fn_628( 3u64 => { match __v_11.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_13]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_3, __v_14]; 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_616] = { let __args: [G; IN_616] = [__v_3, __v_14]; 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 __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_602] = { let __args: [G; IN_602] = [__v_4, __v_15]; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_24, __v_25]; 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_603] = { let __args: [G; IN_603] = [__v_24, __v_25]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23, __v_26]; 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_603] = { let __args: [G; IN_603] = [__v_23, __v_26]; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_22, __v_27]; 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_603] = { let __args: [G; IN_603] = [__v_22, __v_27]; 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_28: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_28]; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_28]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54031,14 +54070,14 @@ fn aiur_fn_628( 4u64 => { match __v_11.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_13]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_22, __v_23]; 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_603] = { let __args: [G; IN_603] = [__v_22, __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_24: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_24]; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_24]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54049,18 +54088,18 @@ fn aiur_fn_628( 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_13]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_602] = { let __args: [G; IN_602] = [__v_3, __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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23, __v_24]; 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_603] = { let __args: [G; IN_603] = [__v_23, __v_24]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_22, __v_25]; 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_603] = { let __args: [G; IN_603] = [__v_22, __v_25]; 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_26: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_26]; - record.function_queries[628].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)); return Ok(__ret); }, _ => { @@ -54071,38 +54110,34 @@ fn aiur_fn_628( 5u64 => { match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_602] = { let __args: [G; IN_602] = [__v_6, __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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_8, __v_19]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_3, __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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_602] = { let __args: [G; IN_602] = [__v_4, __v_15]; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_26: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; - let __v_27: G = __r_arr[0]; + let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_26, __v_27]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_13]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_603] = { let __args: [G; IN_603] = [__v_28, __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_30: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29, __v_30]; 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_603] = { let __args: [G; IN_603] = [__v_25, __v_30]; 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_31: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26, __v_31]; 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_603] = { let __args: [G; IN_603] = [__v_24, __v_31]; 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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_25, __v_32]; 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_603] = { let __args: [G; IN_603] = [__v_23, __v_32]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_24, __v_33]; 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_603] = { let __args: [G; IN_603] = [__v_22, __v_33]; 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_34: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23, __v_34]; 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_35: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_22, __v_35]; 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_36: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_36]; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_34]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54113,26 +54148,26 @@ fn aiur_fn_628( 6u64 => { match __v_11.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_602] = { let __args: [G; IN_602] = [__v_4, __v_15]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_5, __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_602] = { let __args: [G; IN_602] = [__v_5, __v_16]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_602] = { let __args: [G; IN_602] = [__v_6, __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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_13]; 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 __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_25, __v_26]; 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_603] = { let __args: [G; IN_603] = [__v_25, __v_26]; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_24, __v_27]; 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_603] = { let __args: [G; IN_603] = [__v_24, __v_27]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23, __v_28]; 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_603] = { let __args: [G; IN_603] = [__v_23, __v_28]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_22, __v_29]; 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_603] = { let __args: [G; IN_603] = [__v_22, __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_30: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_30]; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_30]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54143,38 +54178,38 @@ fn aiur_fn_628( 7u64 => { match __v_11.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_602] = { let __args: [G; IN_602] = [__v_3, __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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_602] = { let __args: [G; IN_602] = [__v_4, __v_15]; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_5, __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_602] = { let __args: [G; IN_602] = [__v_5, __v_16]; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_602] = { let __args: [G; IN_602] = [__v_6, __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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_8, __v_19]; 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_602] = { let __args: [G; IN_602] = [__v_8, __v_19]; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_2, __v_13]; 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_616] = { let __args: [G; IN_616] = [__v_2, __v_13]; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_7, __v_18]; 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_626] = { let __args: [G; IN_626] = [__v_7, __v_18]; 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_600] = { let __args: [G; IN_600] = [__v_28, __v_29]; 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_603] = { let __args: [G; IN_603] = [__v_28, __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_30: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_27, __v_30]; 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_603] = { let __args: [G; IN_603] = [__v_27, __v_30]; 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_31: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26, __v_31]; 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_603] = { let __args: [G; IN_603] = [__v_26, __v_31]; 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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_25, __v_32]; 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_603] = { let __args: [G; IN_603] = [__v_25, __v_32]; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_24, __v_33]; 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_603] = { let __args: [G; IN_603] = [__v_24, __v_33]; 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_34: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23, __v_34]; 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_603] = { let __args: [G; IN_603] = [__v_23, __v_34]; 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_35: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_22, __v_35]; 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_603] = { let __args: [G; IN_603] = [__v_22, __v_35]; 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_36: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_36]; - record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_631] = [__v_36]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54189,15 +54224,15 @@ fn aiur_fn_628( }) } -const INPUT_SIZE_629: usize = 23; -const IN_629: usize = 23; -const OUT_629: usize = 2; -fn aiur_fn_629( - inp: [G; IN_629], +const INPUT_SIZE_632: usize = 23; +const IN_632: usize = 23; +const OUT_632: usize = 2; +fn aiur_fn_632( + inp: [G; IN_632], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_629], 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]; @@ -54222,42 +54257,42 @@ fn aiur_fn_629( let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; - 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]; 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_629] = { let __args: [G; IN_629] = [__v_0, __v_1, __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[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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_11, __v_12, __v_13, __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[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_629] = { let __args: [G; IN_629] = [__v_11, __v_12, __v_13, __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[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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_23, __v_24]; 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_602] = { let __args: [G; IN_602] = [__v_23, __v_24]; 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_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; 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_633] = { let __args: [G; IN_633] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __ret: [G; OUT_629] = [__v_26, __v_27]; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_632] = [__v_26, __v_27]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_25]; 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_610] = { let __args: [G; IN_610] = [__v_25]; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __ret: [G; OUT_629] = [__v_26, __v_27]; - record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_632] = [__v_26, __v_27]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_630: usize = 23; -const IN_630: usize = 23; -const OUT_630: usize = 2; -fn aiur_fn_630( - inp: [G; IN_630], +const INPUT_SIZE_633: usize = 23; +const IN_633: usize = 23; +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_630], 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]; @@ -54286,25 +54321,25 @@ fn aiur_fn_630( 1u64 => { match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_23]; 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_610] = { let __args: [G; IN_610] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_13, __v_22]; 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 = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_3, __v_14, __v_22]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_3, __v_14, __v_22]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_26, __v_27, __v_28, __v_29]; 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_609] = { let __args: [G; IN_609] = [__v_26, __v_27, __v_28, __v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_30, __v_31]; 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_609] = { let __args: [G; IN_609] = [__v_24, __v_25, __v_30, __v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __ret: [G; OUT_630] = [__v_32, __v_33]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_32, __v_33]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54315,25 +54350,25 @@ fn aiur_fn_630( 2u64 => { match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_23]; 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_610] = { let __args: [G; IN_610] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_13, __v_22]; 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 = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_3, __v_14, __v_22]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_3, __v_14, __v_22]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_26, __v_27, __v_28, __v_29]; 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_609] = { let __args: [G; IN_609] = [__v_26, __v_27, __v_28, __v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_30, __v_31]; 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_609] = { let __args: [G; IN_609] = [__v_24, __v_25, __v_30, __v_31]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __ret: [G; OUT_630] = [__v_32, __v_33]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_32, __v_33]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54344,33 +54379,33 @@ fn aiur_fn_630( 3u64 => { match __v_11.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_23]; 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_610] = { let __args: [G; IN_610] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_13, __v_22]; 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 = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_3, __v_14, __v_22]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_3, __v_14, __v_22]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_602] = { let __args: [G; IN_602] = [__v_4, __v_15]; 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_30: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_30]; 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_610] = { let __args: [G; IN_610] = [__v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_28, __v_29, __v_31, __v_32]; 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_609] = { let __args: [G; IN_609] = [__v_28, __v_29, __v_31, __v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_26, __v_27, __v_33, __v_34]; 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_609] = { let __args: [G; IN_609] = [__v_26, __v_27, __v_33, __v_34]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_35, __v_36]; 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_609] = { let __args: [G; IN_609] = [__v_24, __v_25, __v_35, __v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __ret: [G; OUT_630] = [__v_37, __v_38]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_37, __v_38]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54381,19 +54416,19 @@ fn aiur_fn_630( 4u64 => { match __v_11.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_23]; 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_610] = { let __args: [G; IN_610] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_13, __v_22]; 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 = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_26, __v_27]; 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_609] = { let __args: [G; IN_609] = [__v_24, __v_25, __v_26, __v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_630] = [__v_28, __v_29]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_28, __v_29]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54404,27 +54439,27 @@ fn aiur_fn_630( 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_23]; 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_610] = { let __args: [G; IN_610] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_13, __v_22]; 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 = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_602] = { let __args: [G; IN_602] = [__v_3, __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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_28]; 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_610] = { let __args: [G; IN_610] = [__v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_26, __v_27, __v_29, __v_30]; 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_609] = { let __args: [G; IN_609] = [__v_26, __v_27, __v_29, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_31, __v_32]; 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_609] = { let __args: [G; IN_609] = [__v_24, __v_25, __v_31, __v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __ret: [G; OUT_630] = [__v_33, __v_34]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_33, __v_34]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54435,63 +54470,55 @@ fn aiur_fn_630( 5u64 => { match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_602] = { let __args: [G; IN_602] = [__v_6, __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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_23]; 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_610] = { let __args: [G; IN_610] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_8, __v_19]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__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_610] = { let __args: [G; IN_610] = [__v_26]; 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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_3, __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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_29]; 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_610] = { let __args: [G; IN_610] = [__v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_602] = { let __args: [G; IN_602] = [__v_4, __v_15]; 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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_32]; 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_610] = { let __args: [G; IN_610] = [__v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_197] = { let __args: [G; IN_197] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_35]; 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_197] = { let __args: [G; IN_197] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __v_37: G = __r_arr[1]; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_35, __v_36]; 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_37: G = __r_arr[0]; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_37]; 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_38: G = __r_arr[0]; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; - let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_38, __v_39]; 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_39: G = __r_arr[1]; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_13, __v_22]; 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_40: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_40]; 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_41: G = __r_arr[0]; - let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __v_43: G = __r_arr[0]; - let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_41, __v_42, __v_43, __v_44]; 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_45: G = __r_arr[0]; - let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_36, __v_37, __v_45, __v_46]; 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_47: G = __r_arr[0]; - let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_33, __v_34, __v_47, __v_48]; 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_49: G = __r_arr[0]; - let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_30, __v_31, __v_49, __v_50]; 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_51: G = __r_arr[0]; - let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_27, __v_28, __v_51, __v_52]; 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_53: G = __r_arr[0]; - let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_53, __v_54]; 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_55: G = __r_arr[0]; - let __v_56: G = __r_arr[1]; - let __ret: [G; OUT_630] = [__v_55, __v_56]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_41: G = __r_arr[1]; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_38, __v_39, __v_40, __v_41]; 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_42: G = __r_arr[0]; + let __v_43: G = __r_arr[1]; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_33, __v_34, __v_42, __v_43]; 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_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_30, __v_31, __v_44, __v_45]; 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_46: G = __r_arr[0]; + let __v_47: G = __r_arr[1]; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_27, __v_28, __v_46, __v_47]; 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_48: G = __r_arr[0]; + let __v_49: G = __r_arr[1]; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_24, __v_25, __v_48, __v_49]; 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_50: G = __r_arr[0]; + let __v_51: G = __r_arr[1]; + let __ret: [G; OUT_633] = [__v_50, __v_51]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54502,43 +54529,43 @@ fn aiur_fn_630( 6u64 => { match __v_11.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_23]; 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_610] = { let __args: [G; IN_610] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_602] = { let __args: [G; IN_602] = [__v_4, __v_15]; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__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_610] = { let __args: [G; IN_610] = [__v_26]; 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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_5, __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_602] = { let __args: [G; IN_602] = [__v_5, __v_16]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_29]; 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_610] = { let __args: [G; IN_610] = [__v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_602] = { let __args: [G; IN_602] = [__v_6, __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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_32]; 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_610] = { let __args: [G; IN_610] = [__v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_13, __v_22]; 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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_33, __v_34, __v_35, __v_36]; 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_609] = { let __args: [G; IN_609] = [__v_33, __v_34, __v_35, __v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_30, __v_31, __v_37, __v_38]; 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_609] = { let __args: [G; IN_609] = [__v_30, __v_31, __v_37, __v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_27, __v_28, __v_39, __v_40]; 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_609] = { let __args: [G; IN_609] = [__v_27, __v_28, __v_39, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_41, __v_42]; 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_609] = { let __args: [G; IN_609] = [__v_24, __v_25, __v_41, __v_42]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __ret: [G; OUT_630] = [__v_43, __v_44]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_43, __v_44]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54549,65 +54576,65 @@ fn aiur_fn_630( 7u64 => { match __v_11.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_12]; 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_602] = { let __args: [G; IN_602] = [__v_1, __v_12]; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_23]; 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_610] = { let __args: [G; IN_610] = [__v_23]; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_14]; 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_602] = { let __args: [G; IN_602] = [__v_3, __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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__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_610] = { let __args: [G; IN_610] = [__v_26]; 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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_4, __v_15]; 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_602] = { let __args: [G; IN_602] = [__v_4, __v_15]; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_29]; 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_610] = { let __args: [G; IN_610] = [__v_29]; 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_5, __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_602] = { let __args: [G; IN_602] = [__v_5, __v_16]; 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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_32]; 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_610] = { let __args: [G; IN_610] = [__v_32]; 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_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_17]; 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_602] = { let __args: [G; IN_602] = [__v_6, __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_35: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_35]; 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_610] = { let __args: [G; IN_610] = [__v_35]; 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_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_8, __v_19]; 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_602] = { let __args: [G; IN_602] = [__v_8, __v_19]; 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_38: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_38]; 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_610] = { let __args: [G; IN_610] = [__v_38]; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_13, __v_22]; 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 __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_2, __v_13, __v_22]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_7, __v_18, __v_22]; 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_628] = { let __args: [G; IN_628] = [__v_7, __v_18, __v_22]; 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_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_41, __v_42, __v_43, __v_44]; 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_609] = { let __args: [G; IN_609] = [__v_41, __v_42, __v_43, __v_44]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_39, __v_40, __v_45, __v_46]; 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_609] = { let __args: [G; IN_609] = [__v_39, __v_40, __v_45, __v_46]; 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_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_36, __v_37, __v_47, __v_48]; 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_609] = { let __args: [G; IN_609] = [__v_36, __v_37, __v_47, __v_48]; 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_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_33, __v_34, __v_49, __v_50]; 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_609] = { let __args: [G; IN_609] = [__v_33, __v_34, __v_49, __v_50]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_30, __v_31, __v_51, __v_52]; 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_609] = { let __args: [G; IN_609] = [__v_30, __v_31, __v_51, __v_52]; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_27, __v_28, __v_53, __v_54]; 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_609] = { let __args: [G; IN_609] = [__v_27, __v_28, __v_53, __v_54]; 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_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_25, __v_55, __v_56]; 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_609] = { let __args: [G; IN_609] = [__v_24, __v_25, __v_55, __v_56]; 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_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __ret: [G; OUT_630] = [__v_57, __v_58]; - record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_633] = [__v_57, __v_58]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54622,15 +54649,15 @@ fn aiur_fn_630( }) } -const INPUT_SIZE_631: usize = 4; -const IN_631: usize = 4; -const OUT_631: usize = 1; -fn aiur_fn_631( - inp: [G; IN_631], +const INPUT_SIZE_634: usize = 4; +const IN_634: usize = 4; +const OUT_634: usize = 1; +fn aiur_fn_634( + inp: [G; IN_634], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_631], 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]; @@ -54645,8 +54672,8 @@ fn aiur_fn_631( 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_631] = [__v_9]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_634] = [__v_9]; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -54662,11 +54689,11 @@ fn aiur_fn_631( let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; 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_636] = { let __args: [G; IN_636] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __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_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = (__v_3 + __v_19); - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_0, __v_6, __v_2, __v_20]; 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_634] = { let __args: [G; IN_634] = [__v_0, __v_6, __v_2, __v_20]; 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_21: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_18, __v_0]; 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_22: G = __r_arr[0]; @@ -54674,13 +54701,13 @@ fn aiur_fn_631( 1u64 => { let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 3] = [__v_23, __v_3, __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_631] = [__v_24]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_634] = [__v_24]; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_631] = [__v_21]; - record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_634] = [__v_21]; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54695,15 +54722,15 @@ fn aiur_fn_631( }) } -const INPUT_SIZE_632: usize = 1; -const IN_632: usize = 1; -const OUT_632: usize = 0; -fn aiur_fn_632( - inp: [G; IN_632], +const INPUT_SIZE_635: usize = 1; +const IN_635: usize = 1; +const OUT_635: usize = 0; +fn aiur_fn_635( + inp: [G; IN_635], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_632], ExecError> { +) -> Result<[G; OUT_635], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -54743,22 +54770,22 @@ fn aiur_fn_632( 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 __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_33, __v_36, __v_37, __v_0]; 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 __ret: [G; OUT_632] = []; - record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_0, __v_33, __v_36, __v_37, __v_0]; 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 __ret: [G; OUT_635] = []; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_633: usize = 12; -const IN_633: usize = 12; -const OUT_633: usize = 1; -fn aiur_fn_633( - inp: [G; IN_633], +const INPUT_SIZE_636: usize = 12; +const IN_636: usize = 12; +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_633], 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]; @@ -54774,12 +54801,12 @@ fn aiur_fn_633( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_633] = [__v_10]; - record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_636] = [__v_7]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_11, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_11, __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_12: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -54795,8 +54822,8 @@ fn aiur_fn_633( let __v_23: G = __loaded[10]; match __v_13.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_633] = [__v_23]; - record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_636] = [__v_20]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54833,15 +54860,15 @@ fn aiur_fn_633( let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 32] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_633] = [__v_56]; - record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_636] = [__v_56]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 7u64 => { - let __ret: [G; OUT_633] = [__v_10]; - record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_636] = [__v_10]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54878,23 +54905,23 @@ fn aiur_fn_633( 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 __ret: [G; OUT_633] = [__v_44]; - record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_636] = [__v_44]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_634: usize = 5; -const IN_634: usize = 5; -const OUT_634: usize = 0; -fn aiur_fn_634( - inp: [G; IN_634], +const INPUT_SIZE_637: usize = 5; +const IN_637: usize = 5; +const OUT_637: usize = 0; +fn aiur_fn_637( + inp: [G; IN_637], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_634], 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]; @@ -54907,9 +54934,9 @@ fn aiur_fn_634( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_1, __v_2, __v_4]; 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 __ret: [G; OUT_634] = []; - record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_1, __v_2, __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 __ret: [G; OUT_637] = []; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -54925,30 +54952,30 @@ fn aiur_fn_634( let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_4]; 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_636] = { let __args: [G; IN_636] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_4]; 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_19: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_19, __v_1]; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __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_721] = { let __args: [G; IN_721] = [__v_2, __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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_3 + __v_22); - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_7, __v_19, __v_21, __v_23, __v_4]; 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 __ret: [G; OUT_634] = []; - record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_7, __v_19, __v_21, __v_23, __v_4]; 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 __ret: [G; OUT_637] = []; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_1, __v_2, __v_4]; 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_19, __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 __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_1, __v_2, __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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_19, __v_3]; 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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_3 + __v_22); - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_7, __v_19, __v_21, __v_23, __v_4]; 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 __ret: [G; OUT_634] = []; - record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_7, __v_19, __v_21, __v_23, __v_4]; 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 __ret: [G; OUT_637] = []; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -54963,15 +54990,15 @@ fn aiur_fn_634( }) } -const INPUT_SIZE_635: usize = 2; -const IN_635: usize = 2; -const OUT_635: usize = 1; -fn aiur_fn_635( - inp: [G; IN_635], +const INPUT_SIZE_638: usize = 2; +const IN_638: usize = 2; +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_635], 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]; @@ -55015,8 +55042,8 @@ fn aiur_fn_635( 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_635] = [__v_38]; - record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_638] = [__v_38]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -55025,8 +55052,8 @@ fn aiur_fn_635( let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = { let __values: [G; 3] = [__v_36, __v_1, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_635] = [__v_40]; - record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_638] = [__v_40]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55036,15 +55063,15 @@ fn aiur_fn_635( }) } -const INPUT_SIZE_636: usize = 3; -const IN_636: usize = 3; -const OUT_636: usize = 0; -fn aiur_fn_636( - inp: [G; IN_636], +const INPUT_SIZE_639: usize = 3; +const IN_639: usize = 3; +const OUT_639: usize = 0; +fn aiur_fn_639( + inp: [G; IN_639], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_636], 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]; @@ -55086,8 +55113,8 @@ fn aiur_fn_636( let __v_36: G = __r_arr[0]; match __v_36.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_636] = []; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_639] = []; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -55095,19 +55122,19 @@ fn aiur_fn_636( let __v_37: G = __r_arr[0]; match __v_37.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_636] = []; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_639] = []; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_636] = []; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_639] = []; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__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 __ret: [G; OUT_636] = []; - record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__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 __ret: [G; OUT_639] = []; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55119,39 +55146,39 @@ fn aiur_fn_636( }) } -const INPUT_SIZE_637: usize = 2; -const IN_637: usize = 2; -const OUT_637: usize = 0; -fn aiur_fn_637( - inp: [G; IN_637], +const INPUT_SIZE_640: usize = 2; +const IN_640: usize = 2; +const OUT_640: usize = 0; +fn aiur_fn_640( + inp: [G; IN_640], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_637], 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 __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !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_641] = { let __args: [G; IN_641] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_637] = []; - record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_640] = []; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_637] = []; - record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_640] = []; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_2, __v_1]; 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_644] = { let __args: [G; IN_644] = [__v_2, __v_1]; 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 __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4]; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_4]; 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_643] = { let __args: [G; IN_643] = [__v_4]; 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_6: G = __r_arr[0]; let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_6, __v_2]; 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_7: G = __r_arr[0]; @@ -55163,23 +55190,23 @@ fn aiur_fn_637( if (__v_7 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); } - let __ret: [G; OUT_637] = []; - record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_640] = []; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_638: usize = 2; -const IN_638: usize = 2; -const OUT_638: usize = 1; -fn aiur_fn_638( - inp: [G; IN_638], +const INPUT_SIZE_641: usize = 2; +const IN_641: usize = 2; +const OUT_641: usize = 1; +fn aiur_fn_641( + inp: [G; IN_641], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_638], 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]; @@ -55192,12 +55219,12 @@ fn aiur_fn_638( 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_638] = [__v_7]; - record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_641] = [__v_7]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_5: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -55211,21 +55238,21 @@ fn aiur_fn_638( let __v_14: G = __loaded[8]; let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_4, __v_1]; 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_641] = { let __args: [G; IN_641] = [__v_4, __v_1]; 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_17: G = __r_arr[0]; - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; 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_629] = { let __args: [G; IN_629] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 3] = [__v_19, __v_3, __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_638] = [__v_20]; - record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_641] = [__v_20]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_638] = [__v_17]; - record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_641] = [__v_17]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55237,15 +55264,15 @@ fn aiur_fn_638( }) } -const INPUT_SIZE_639: usize = 1; -const IN_639: usize = 1; -const OUT_639: usize = 1; -fn aiur_fn_639( - inp: [G; IN_639], +const INPUT_SIZE_642: usize = 1; +const IN_642: usize = 1; +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_639], ExecError> { +) -> Result<[G; OUT_642], 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 }; @@ -55255,8 +55282,8 @@ fn aiur_fn_639( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_639] = [__v_4]; - record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_4]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -55264,16 +55291,16 @@ fn aiur_fn_639( let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_3]; 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_642] = { let __args: [G; IN_642] = [__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_5: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_5]; - record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_5]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_639] = [__v_5]; - record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_642] = [__v_5]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55285,15 +55312,15 @@ fn aiur_fn_639( }) } -const INPUT_SIZE_640: usize = 1; -const IN_640: usize = 1; -const OUT_640: usize = 1; -fn aiur_fn_640( - inp: [G; IN_640], +const INPUT_SIZE_643: usize = 1; +const IN_643: usize = 1; +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_640], ExecError> { +) -> Result<[G; OUT_643], 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 }; @@ -55305,17 +55332,17 @@ fn aiur_fn_640( 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_640] = [__v_6]; - record.function_queries[640].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 => { - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_3]; 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_643] = { let __args: [G; IN_643] = [__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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2, __v_4]; 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_724] = { let __args: [G; IN_724] = [__v_2, __v_4]; 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_5: G = __r_arr[0]; - let __ret: [G; OUT_640] = [__v_5]; - record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_643] = [__v_5]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55325,15 +55352,15 @@ fn aiur_fn_640( }) } -const INPUT_SIZE_641: usize = 2; -const IN_641: usize = 2; -const OUT_641: usize = 1; -fn aiur_fn_641( - inp: [G; IN_641], +const INPUT_SIZE_644: usize = 2; +const IN_644: usize = 2; +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_641], 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]; @@ -55343,53 +55370,53 @@ fn aiur_fn_641( 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 = { let __values: [G; 3] = [__v_2, __v_0, __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(32); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_6, __v_1, __v_7]; 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_645] = { let __args: [G; IN_645] = [__v_6, __v_1, __v_7]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_641] = [__v_8]; - record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_644] = [__v_8]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -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_645: usize = 3; +const IN_645: usize = 3; +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_642], ExecError> { +) -> Result<[G; OUT_645], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_642] = [__v_0]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_645] = [__v_0]; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_0]; 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_643] = { let __args: [G; IN_643] = [__v_0]; 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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_3, __v_1]; 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_646] = { let __args: [G; IN_646] = [__v_0, __v_3, __v_1]; 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 __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_0, __v_4]; 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_652] = { let __args: [G; IN_652] = [__v_0, __v_4]; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_642] = [__v_0]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_645] = [__v_0]; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_1, __v_7]; 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_645] = { let __args: [G; IN_645] = [__v_4, __v_1, __v_7]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_642] = [__v_8]; - record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_645] = [__v_8]; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55398,15 +55425,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_646: usize = 3; +const IN_646: usize = 3; +const OUT_646: usize = 1; +fn aiur_fn_646( + inp: [G; IN_646], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_643], 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]; @@ -55420,19 +55447,19 @@ fn aiur_fn_643( 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_643] = [__v_8]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_646] = [__v_8]; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1, __v_2]; 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_647] = { let __args: [G; IN_647] = [__v_4, __v_1, __v_2]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_1, __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_646] = { let __args: [G; IN_646] = [__v_5, __v_1, __v_2]; 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 __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_6, __v_7]; 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_724] = { let __args: [G; IN_724] = [__v_6, __v_7]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_643] = [__v_8]; - record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_646] = [__v_8]; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55442,15 +55469,15 @@ fn aiur_fn_643( }) } -const INPUT_SIZE_644: usize = 3; -const IN_644: usize = 3; -const OUT_644: usize = 1; -fn aiur_fn_644( - inp: [G; IN_644], +const INPUT_SIZE_647: usize = 3; +const IN_647: usize = 3; +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_644], 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]; @@ -55462,8 +55489,8 @@ fn aiur_fn_644( 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_644] = [__v_6]; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_647] = [__v_6]; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -55472,32 +55499,32 @@ fn aiur_fn_644( 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_644] = [__v_8]; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_647] = [__v_8]; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_1, __v_2]; 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_648] = { let __args: [G; IN_648] = [__v_0, __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 __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_1, __v_2]; 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_650] = { let __args: [G; IN_650] = [__v_4, __v_1, __v_2]; 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_5: G = __r_arr[0]; - let __ret: [G; OUT_644] = [__v_5]; - record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_647] = [__v_5]; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_645: usize = 3; -const IN_645: usize = 3; -const OUT_645: usize = 1; -fn aiur_fn_645( - inp: [G; IN_645], +const INPUT_SIZE_648: usize = 3; +const IN_648: usize = 3; +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_645], 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]; @@ -55511,17 +55538,17 @@ fn aiur_fn_645( 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_645] = [__v_8]; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_648] = [__v_8]; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_5, __v_1, __v_2]; 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_648] = { let __args: [G; IN_648] = [__v_5, __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 __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_6, __v_1, __v_2]; 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_649] = { let __args: [G; IN_649] = [__v_4, __v_6, __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 __v_7: G = __r_arr[0]; - let __ret: [G; OUT_645] = [__v_7]; - record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_648] = [__v_7]; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55531,15 +55558,15 @@ fn aiur_fn_645( }) } -const INPUT_SIZE_646: usize = 4; -const IN_646: usize = 4; -const OUT_646: usize = 1; -fn aiur_fn_646( - inp: [G; IN_646], +const INPUT_SIZE_649: usize = 4; +const IN_649: usize = 4; +const OUT_649: usize = 1; +fn aiur_fn_649( + inp: [G; IN_649], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_646], 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]; @@ -55556,12 +55583,12 @@ fn aiur_fn_646( 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_646] = [__v_11]; - record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_11]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __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_729] = { let __args: [G; IN_729] = [__v_3, __v_0]; 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_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -55575,7 +55602,7 @@ fn aiur_fn_646( let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_3, __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_19: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -55589,24 +55616,24 @@ fn aiur_fn_646( let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_8, __v_9, __v_10, __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_28, __v_29, __v_30, __v_2]; 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_632] = { let __args: [G; IN_632] = [__v_8, __v_9, __v_10, __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_28, __v_29, __v_30, __v_2]; 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_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_646] = [__v_34]; - record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_34]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_6, __v_2, __v_3]; 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_649] = { let __args: [G; IN_649] = [__v_0, __v_6, __v_2, __v_3]; 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_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_646] = [__v_35]; - record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_649] = [__v_35]; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55618,15 +55645,15 @@ fn aiur_fn_646( }) } -const INPUT_SIZE_647: usize = 3; -const IN_647: usize = 3; -const OUT_647: usize = 1; -fn aiur_fn_647( - inp: [G; IN_647], +const INPUT_SIZE_650: usize = 3; +const IN_650: usize = 3; +const OUT_650: usize = 1; +fn aiur_fn_650( + inp: [G; IN_650], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_647], 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]; @@ -55640,8 +55667,8 @@ fn aiur_fn_647( 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_647] = [__v_8]; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_8]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -55650,10 +55677,10 @@ fn aiur_fn_647( 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_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_4, __v_10]; 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_651] = { let __args: [G; IN_651] = [__v_5, __v_1, __v_2, __v_4, __v_10]; 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 __v_11: G = __r_arr[0]; - let __ret: [G; OUT_647] = [__v_11]; - record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_650] = [__v_11]; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55663,15 +55690,15 @@ fn aiur_fn_647( }) } -const INPUT_SIZE_648: usize = 5; -const IN_648: usize = 5; -const OUT_648: usize = 1; -fn aiur_fn_648( - inp: [G; IN_648], +const INPUT_SIZE_651: usize = 5; +const IN_651: usize = 5; +const OUT_651: usize = 1; +fn aiur_fn_651( + inp: [G; IN_651], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_648], 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]; @@ -55689,12 +55716,12 @@ fn aiur_fn_648( 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_648] = [__v_12]; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_651] = [__v_12]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_2, __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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -55708,7 +55735,7 @@ fn aiur_fn_648( let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_6]; 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_729] = { let __args: [G; IN_729] = [__v_2, __v_6]; 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_20: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -55722,17 +55749,17 @@ fn aiur_fn_648( let __v_29: G = __loaded[8]; let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_9, __v_10, __v_11, __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_29, __v_30, __v_31, __v_1]; 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_632] = { let __args: [G; IN_632] = [__v_9, __v_10, __v_11, __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_29, __v_30, __v_31, __v_1]; 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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __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_721] = { let __args: [G; IN_721] = [__v_4, __v_6]; 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_34: G = __r_arr[0]; - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2, __v_6, __v_34]; 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_651] = { let __args: [G; IN_651] = [__v_7, __v_1, __v_2, __v_6, __v_34]; 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 __v_35: G = __r_arr[0]; - let __ret: [G; OUT_648] = [__v_35]; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_651] = [__v_35]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55742,11 +55769,11 @@ fn aiur_fn_648( 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_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2, __v_6, __v_39]; 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_651] = { let __args: [G; IN_651] = [__v_7, __v_1, __v_2, __v_6, __v_39]; 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 __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_648] = [__v_41]; - record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_651] = [__v_41]; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55758,15 +55785,15 @@ fn aiur_fn_648( }) } -const INPUT_SIZE_649: usize = 2; -const IN_649: usize = 2; -const OUT_649: usize = 1; -fn aiur_fn_649( - inp: [G; IN_649], +const INPUT_SIZE_652: usize = 2; +const IN_652: usize = 2; +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_649], ExecError> { +) -> Result<[G; OUT_652], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55783,14 +55810,14 @@ fn aiur_fn_649( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_649] = [__v_8]; - record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = [__v_8]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_649] = [__v_8]; - record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = [__v_8]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55803,8 +55830,8 @@ fn aiur_fn_649( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_649] = [__v_8]; - record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = [__v_8]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -55813,15 +55840,15 @@ fn aiur_fn_649( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_649] = [__v_9]; - record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = [__v_9]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_4, __v_7]; 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_652] = { let __args: [G; IN_652] = [__v_4, __v_7]; 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_9: G = __r_arr[0]; - let __ret: [G; OUT_649] = [__v_9]; - record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_652] = [__v_9]; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -55838,15 +55865,15 @@ fn aiur_fn_649( }) } -const INPUT_SIZE_650: usize = 11; -const IN_650: usize = 11; -const OUT_650: usize = 1; -fn aiur_fn_650( - inp: [G; IN_650], +const INPUT_SIZE_653: usize = 11; +const IN_653: usize = 11; +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_650], ExecError> { +) -> Result<[G; OUT_653], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55861,56 +55888,56 @@ fn aiur_fn_650( let __v_10: G = inp[10]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_650] = [__v_3]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_3]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_650] = [__v_11]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_11]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_650] = [__v_11]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_11]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 2u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_650] = [__v_11]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_11]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_650] = [__v_4]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_4]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_650] = [__v_11]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_11]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_650] = [__v_8]; - record.function_queries[650].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)); return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_650] = [__v_7]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_7]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_650] = [__v_9]; - record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_653] = [__v_9]; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -55920,15 +55947,15 @@ fn aiur_fn_650( }) } -const INPUT_SIZE_651: usize = 2; -const IN_651: usize = 2; -const OUT_651: usize = 1; -fn aiur_fn_651( - inp: [G; IN_651], +const INPUT_SIZE_654: usize = 2; +const IN_654: usize = 2; +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_651], ExecError> { +) -> Result<[G; OUT_654], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55940,18 +55967,18 @@ fn aiur_fn_651( match __v_2.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_651] = [__v_6]; - record.function_queries[651].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); }, 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_651] = [__v_6]; - record.function_queries[651].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); }, 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; 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_729] = { let __args: [G; IN_729] = [__v_1, __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_6: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -55966,67 +55993,67 @@ fn aiur_fn_651( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__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[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 __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__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[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 __v_20: G = (__v_18 - __v_19); - let __ret: [G; OUT_651] = [__v_20]; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_654] = [__v_20]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_3, __v_1]; 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_654] = { let __args: [G; IN_654] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_1]; 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_654] = { let __args: [G; IN_654] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); - let __ret: [G; OUT_651] = [__v_8]; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_654] = [__v_8]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_3, __v_1]; 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_654] = { let __args: [G; IN_654] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_1]; 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_654] = { let __args: [G; IN_654] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); - let __ret: [G; OUT_651] = [__v_8]; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_654] = [__v_8]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_3, __v_1]; 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_654] = { let __args: [G; IN_654] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_1]; 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_654] = { let __args: [G; IN_654] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); - let __ret: [G; OUT_651] = [__v_8]; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_654] = [__v_8]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_3, __v_1]; 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_654] = { let __args: [G; IN_654] = [__v_3, __v_1]; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_1]; 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_654] = { let __args: [G; IN_654] = [__v_4, __v_1]; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_5, __v_1]; 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_654] = { let __args: [G; IN_654] = [__v_5, __v_1]; 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_8: G = __r_arr[0]; let __v_9: G = (__v_7 * __v_8); let __v_10: G = (__v_6 * __v_9); - let __ret: [G; OUT_651] = [__v_10]; - record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_654] = [__v_10]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_651] = [__v_6]; - record.function_queries[651].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); }, 8u64 => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_5, __v_1]; 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_654] = { let __args: [G; IN_654] = [__v_5, __v_1]; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_651] = [__v_6]; - record.function_queries[651].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); }, _ => { @@ -56036,34 +56063,34 @@ fn aiur_fn_651( }) } -const INPUT_SIZE_652: usize = 3; -const IN_652: usize = 3; -const OUT_652: usize = 0; -fn aiur_fn_652( - inp: [G; IN_652], +const INPUT_SIZE_655: usize = 3; +const IN_655: usize = 3; +const OUT_655: usize = 0; +fn aiur_fn_655( + inp: [G; IN_655], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_652], ExecError> { +) -> Result<[G; OUT_655], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_652] = []; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_1, __v_2]; 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_654] = { let __args: [G; IN_654] = [__v_1, __v_2]; 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_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() }); } - let __ret: [G; OUT_652] = []; - record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56073,15 +56100,15 @@ fn aiur_fn_652( }) } -const INPUT_SIZE_653: usize = 2; -const IN_653: usize = 2; -const OUT_653: usize = 0; -fn aiur_fn_653( - inp: [G; IN_653], +const INPUT_SIZE_656: usize = 2; +const IN_656: usize = 2; +const OUT_656: usize = 0; +fn aiur_fn_656( + inp: [G; IN_656], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_653], ExecError> { +) -> Result<[G; OUT_656], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56091,28 +56118,28 @@ fn aiur_fn_653( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_653] = []; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3, __v_1]; 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 __ret: [G; OUT_653] = []; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_3, __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 __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3, __v_1]; 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_653] = { let __args: [G; IN_653] = [__v_4, __v_1]; 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 __ret: [G; OUT_653] = []; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_3, __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_656] = { let __args: [G; IN_656] = [__v_4, __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 __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3, __v_1]; 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_653] = { let __args: [G; IN_653] = [__v_4, __v_1]; 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 __ret: [G; OUT_653] = []; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_3, __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_656] = { let __args: [G; IN_656] = [__v_4, __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 __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { @@ -56121,8 +56148,8 @@ fn aiur_fn_653( if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); } - let __ret: [G; OUT_653] = []; - record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56132,15 +56159,15 @@ fn aiur_fn_653( }) } -const INPUT_SIZE_654: usize = 2; -const IN_654: usize = 2; -const OUT_654: usize = 0; -fn aiur_fn_654( - inp: [G; IN_654], +const INPUT_SIZE_657: usize = 2; +const IN_657: usize = 2; +const OUT_657: usize = 0; +fn aiur_fn_657( + inp: [G; IN_657], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_654], 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]; @@ -56150,15 +56177,15 @@ fn aiur_fn_654( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_654] = []; - record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_657] = []; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_3, __v_1]; 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_4, __v_1]; 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 __ret: [G; OUT_654] = []; - record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_3, __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_4, __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 __ret: [G; OUT_657] = []; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56168,15 +56195,15 @@ fn aiur_fn_654( }) } -const INPUT_SIZE_655: usize = 4; -const IN_655: usize = 4; -const OUT_655: usize = 0; -fn aiur_fn_655( - inp: [G; IN_655], +const INPUT_SIZE_658: usize = 4; +const IN_658: usize = 4; +const OUT_658: usize = 0; +fn aiur_fn_658( + inp: [G; IN_658], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_655], 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]; @@ -56194,18 +56221,18 @@ fn aiur_fn_655( if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); } - let __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = []; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_5, __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 __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_5, __v_2]; 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 __ret: [G; OUT_658] = []; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_5]; 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_729] = { let __args: [G; IN_729] = [__v_3, __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_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -56226,55 +56253,55 @@ fn aiur_fn_655( if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); } - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_2]; 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 __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_6, __v_2]; 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 __ret: [G; OUT_658] = []; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_1, __v_2, __v_3]; 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_655] = { let __args: [G; IN_655] = [__v_6, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_5, __v_1, __v_2, __v_3]; 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_658] = { let __args: [G; IN_658] = [__v_6, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_658] = []; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_1, __v_2, __v_3]; 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_658] = { let __args: [G; IN_658] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_658] = []; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_1, __v_2, __v_3]; 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_658] = { let __args: [G; IN_658] = [__v_5, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_6, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_658] = []; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_1, __v_2, __v_3]; 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_655] = { let __args: [G; IN_655] = [__v_6, __v_1, __v_2, __v_3]; 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_658] = { let __args: [G; IN_658] = [__v_5, __v_1, __v_2, __v_3]; 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_658] = { let __args: [G; IN_658] = [__v_6, __v_1, __v_2, __v_3]; 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_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_7, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_7, __v_9, __v_2, __v_3]; 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 __ret: [G; OUT_658] = []; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_658] = []; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_7, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_655] = []; - record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_7, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_658] = []; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56284,15 +56311,15 @@ fn aiur_fn_655( }) } -const INPUT_SIZE_656: usize = 12; -const IN_656: usize = 12; -const OUT_656: usize = 0; -fn aiur_fn_656( - inp: [G; IN_656], +const INPUT_SIZE_659: usize = 12; +const IN_659: usize = 12; +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_656], 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]; @@ -56311,53 +56338,53 @@ fn aiur_fn_656( let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __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[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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_13, __v_14, __v_12, __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_658] = { let __args: [G; IN_658] = [__v_13, __v_14, __v_12, __v_11]; 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)? } }; match __v_0.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_3, __v_15, __v_12, __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 __ret: [G; OUT_656] = []; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_3, __v_15, __v_12, __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 __ret: [G; OUT_656] = []; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_3, __v_15, __v_12, __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 __ret: [G; OUT_656] = []; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_3, __v_15, __v_12, __v_11]; 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 __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_7, __v_12, __v_11]; 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 __ret: [G; OUT_656] = []; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_7, __v_12, __v_11]; 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)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_656] = []; - record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_659] = []; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_657: usize = 3; -const IN_657: usize = 3; -const OUT_657: usize = 0; -fn aiur_fn_657( - inp: [G; IN_657], +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_657], 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]; @@ -56370,18 +56397,18 @@ fn aiur_fn_657( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_657] = []; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_660] = []; + record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_6, __v_8, __v_1, __v_2]; 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_657] = { let __args: [G; IN_657] = [__v_7, __v_1, __v_2]; 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 __ret: [G; OUT_657] = []; - record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_6, __v_8, __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_660] = { let __args: [G; IN_660] = [__v_7, __v_1, __v_2]; 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)); return Ok(__ret); }, } @@ -56393,15 +56420,15 @@ fn aiur_fn_657( }) } -const INPUT_SIZE_658: usize = 2; -const IN_658: usize = 2; -const OUT_658: usize = 0; -fn aiur_fn_658( - inp: [G; IN_658], +const INPUT_SIZE_661: usize = 2; +const IN_661: usize = 2; +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_658], 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]; @@ -56410,7 +56437,7 @@ fn aiur_fn_658( let __v_3: G = G::from_u64(0); let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_2, __v_1, __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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __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_729] = { let __args: [G; IN_729] = [__v_0, __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_5: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -56441,9 +56468,9 @@ fn aiur_fn_658( return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); } let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_11, __v_21]; 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_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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_22]; 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_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 __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; 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_24: G = __r_arr[0]; @@ -56453,8 +56480,8 @@ fn aiur_fn_658( if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64() }); } - let __ret: [G; OUT_658] = []; - record.function_queries[658].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); }, _ => { @@ -56464,15 +56491,15 @@ fn aiur_fn_658( }) } -const INPUT_SIZE_659: usize = 14; -const IN_659: usize = 14; -const OUT_659: usize = 0; -fn aiur_fn_659( - inp: [G; IN_659], +const INPUT_SIZE_662: usize = 14; +const IN_662: usize = 14; +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_659], 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]; @@ -56488,8 +56515,8 @@ fn aiur_fn_659( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_650] = { let __args: [G; IN_650] = [__v_0, __v_1, __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[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 __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_653] = { let __args: [G; IN_653] = [__v_0, __v_1, __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[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_14: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { @@ -56498,9 +56525,9 @@ fn aiur_fn_659( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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 __ret: [G; OUT_659] = []; - record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_14, __v_2, __v_12]; 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 __ret: [G; OUT_662] = []; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -56509,14 +56536,14 @@ fn aiur_fn_659( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_652] = { let __args: [G; IN_652] = [__v_14, __v_3, __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_655] = { let __args: [G; IN_655] = [__v_14, __v_2, __v_12]; 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_655] = { let __args: [G; IN_655] = [__v_14, __v_3, __v_12]; 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_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_659] = []; - record.function_queries[659].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); }, 2u64 => { @@ -56534,14 +56561,14 @@ fn aiur_fn_659( if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); } - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_652] = { let __args: [G; IN_652] = [__v_14, __v_3, __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_655] = { let __args: [G; IN_655] = [__v_14, __v_2, __v_12]; 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_655] = { let __args: [G; IN_655] = [__v_14, __v_3, __v_12]; 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_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_2, __v_26, __v_12, __v_13]; 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 __ret: [G; OUT_659] = []; - record.function_queries[659].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); }, 3u64 => { @@ -56550,12 +56577,12 @@ fn aiur_fn_659( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_652] = { let __args: [G; IN_652] = [__v_14, __v_3, __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_655] = { let __args: [G; IN_655] = [__v_14, __v_2, __v_12]; 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_655] = { let __args: [G; IN_655] = [__v_14, __v_3, __v_12]; 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)? } }; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_659] = []; - record.function_queries[659].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 => { @@ -56563,8 +56590,8 @@ fn aiur_fn_659( let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_2, __v_21, __v_12, __v_13]; 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 __ret: [G; OUT_659] = []; - record.function_queries[659].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); }, _ => { @@ -56578,12 +56605,12 @@ fn aiur_fn_659( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_726] = { let __args: [G; IN_726] = [__v_13, __v_11]; 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_655] = { let __args: [G; IN_655] = [__v_14, __v_2, __v_12]; 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_729] = { let __args: [G; IN_729] = [__v_13, __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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; 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_663] = { let __args: [G; IN_663] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; 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 __ret: [G; OUT_662] = []; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { @@ -56592,18 +56619,13 @@ fn aiur_fn_659( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_595] = { let __args: [G; IN_595] = [__v_11, __v_2, __v_3, __v_4, __v_10, __v_12, __v_13]; 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_529] = { let __args: [G; IN_529] = [__v_11, __v_12]; 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_655] = { let __args: [G; IN_655] = [__v_14, __v_2, __v_12]; 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_598] = { let __args: [G; IN_598] = [__v_11, __v_2, __v_3, __v_4, __v_7, __v_12, __v_13]; 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_530] = { let __args: [G; IN_530] = [__v_11, __v_12]; 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 __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_19, __v_12]; 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_498] = { let __args: [G; IN_498] = [__v_5, __v_3, __v_19, __v_12]; 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_20: G = __r_arr[0]; - if (__v_6 != __v_20) { - return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); - } - let __ret: [G; OUT_659] = []; - record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_19, __v_12]; 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 __ret: [G; OUT_662] = []; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { @@ -56612,9 +56634,9 @@ fn aiur_fn_659( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_561] = { let __args: [G; IN_561] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_726] = { let __args: [G; IN_726] = [__v_12, __v_3]; 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_655] = { let __args: [G; IN_655] = [__v_14, __v_2, __v_12]; 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_562] = { let __args: [G; IN_562] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_729] = { let __args: [G; IN_729] = [__v_12, __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_19: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -56633,7 +56655,7 @@ fn aiur_fn_659( if (__v_5 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); } - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_22, __v_2, __v_23, __v_12, __v_13]; 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_600] = { let __args: [G; IN_600] = [__v_22, __v_2, __v_23, __v_12, __v_13]; 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_484] = { let __args: [G; IN_484] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21]; 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_31: G = (__v_23 + __v_24); let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_22, __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)? } }; @@ -56646,8 +56668,8 @@ fn aiur_fn_659( 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_492] = { let __args: [G; IN_492] = [__v_2, __v_5, __v_3, __v_38, __v_12, __v_13]; 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 __ret: [G; OUT_659] = []; - record.function_queries[659].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); }, _ => { @@ -56661,10 +56683,10 @@ fn aiur_fn_659( 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_437] = { let __args: [G; IN_437] = [__v_2, __v_17, __v_12, __v_13]; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_2, __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_564] = { let __args: [G; IN_564] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; 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_659] = []; - record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_14, __v_2, __v_12]; 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_565] = { let __args: [G; IN_565] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; 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_662] = []; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56674,15 +56696,15 @@ fn aiur_fn_659( }) } -const INPUT_SIZE_660: usize = 6; -const IN_660: usize = 6; -const OUT_660: usize = 0; -fn aiur_fn_660( - inp: [G; IN_660], +const INPUT_SIZE_663: usize = 6; +const IN_663: usize = 6; +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_660], 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]; @@ -56726,7 +56748,7 @@ fn aiur_fn_660( if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); } - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_4, __v_5]; 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_661] = { let __args: [G; IN_661] = [__v_4, __v_5]; 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 __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(6); break '__mc_0 [__v_9, __v_10]; @@ -56755,27 +56777,27 @@ fn aiur_fn_660( return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); } let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_3, __v_7, __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 __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_3, __v_7, __v_8]; 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 __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); } - let __ret: [G; OUT_660] = []; - record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_663] = []; + record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_661: usize = 3; -const IN_661: usize = 3; -const OUT_661: usize = 1; -fn aiur_fn_661( - inp: [G; IN_661], +const INPUT_SIZE_664: usize = 3; +const IN_664: usize = 3; +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_661], 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]; @@ -56784,8 +56806,8 @@ fn aiur_fn_661( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_661] = [__v_4]; - record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_664] = [__v_4]; + record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56798,16 +56820,16 @@ fn aiur_fn_661( 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_6, __v_1, __v_9]; 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_664] = { let __args: [G; IN_664] = [__v_6, __v_1, __v_9]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_661] = [__v_10]; - record.function_queries[661].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)); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_661] = [__v_8]; - record.function_queries[661].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); }, } @@ -56816,37 +56838,37 @@ fn aiur_fn_661( }) } -const INPUT_SIZE_662: usize = 3; -const IN_662: usize = 3; -const OUT_662: usize = 0; -fn aiur_fn_662( - inp: [G; IN_662], +const INPUT_SIZE_665: usize = 3; +const IN_665: usize = 3; +const OUT_665: usize = 0; +fn aiur_fn_665( + inp: [G; IN_665], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_662], ExecError> { +) -> Result<[G; OUT_665], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_1]; 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_635] = { let __args: [G; IN_635] = [__v_1]; 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 = G::from_u64(0); - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_2, __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 __ret: [G; OUT_662] = []; - record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_1, __v_2, __v_3]; 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 __ret: [G; OUT_665] = []; + record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_663: usize = 4; -const IN_663: usize = 4; -const OUT_663: usize = 0; -fn aiur_fn_663( - inp: [G; IN_663], +const INPUT_SIZE_666: usize = 4; +const IN_666: usize = 4; +const OUT_666: usize = 0; +fn aiur_fn_666( + inp: [G; IN_666], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_663], ExecError> { +) -> Result<[G; OUT_666], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56858,8 +56880,8 @@ fn aiur_fn_663( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_663] = []; - record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_666] = []; + record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -56875,12 +56897,12 @@ fn aiur_fn_663( let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_3, __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_662] = { let __args: [G; IN_662] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_3, __v_1, __v_2]; 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_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_6, __v_1, __v_2, __v_19]; 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 __ret: [G; OUT_663] = []; - record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_6, __v_1, __v_2, __v_19]; 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 __ret: [G; OUT_666] = []; + record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56890,15 +56912,15 @@ fn aiur_fn_663( }) } -const INPUT_SIZE_664: usize = 1; -const IN_664: usize = 1; -const OUT_664: usize = 3; -fn aiur_fn_664( - inp: [G; IN_664], +const INPUT_SIZE_667: usize = 1; +const IN_667: usize = 1; +const OUT_667: usize = 3; +fn aiur_fn_667( + inp: [G; IN_667], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_664], ExecError> { +) -> Result<[G; OUT_667], 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)? } }; @@ -56908,8 +56930,8 @@ fn aiur_fn_664( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_664] = [__v_3, __v_4, __v_2]; - record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_667] = [__v_3, __v_4, __v_2]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -56917,8 +56939,8 @@ fn aiur_fn_664( 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_664] = [__v_5, __v_3, __v_4]; - record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_667] = [__v_5, __v_3, __v_4]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56928,15 +56950,15 @@ fn aiur_fn_664( }) } -const INPUT_SIZE_665: usize = 2; -const IN_665: usize = 2; -const OUT_665: usize = 10; -fn aiur_fn_665( - inp: [G; IN_665], +const INPUT_SIZE_668: usize = 2; +const IN_668: usize = 2; +const OUT_668: usize = 10; +fn aiur_fn_668( + inp: [G; IN_668], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_665], 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]; @@ -56944,8 +56966,8 @@ fn aiur_fn_665( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_665] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; - record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_668] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56960,23 +56982,23 @@ fn aiur_fn_665( 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_665] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_668] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_666: usize = 2; -const IN_666: usize = 2; -const OUT_666: usize = 3; -fn aiur_fn_666( - inp: [G; IN_666], +const INPUT_SIZE_669: usize = 2; +const IN_669: usize = 2; +const OUT_669: usize = 3; +fn aiur_fn_669( + inp: [G; IN_669], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_666], 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]; @@ -56984,8 +57006,8 @@ fn aiur_fn_666( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_666] = [__v_2, __v_3, __v_1]; - record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_669] = [__v_2, __v_3, __v_1]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -56993,23 +57015,23 @@ fn aiur_fn_666( 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_666] = [__v_4, __v_2, __v_3]; - record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_669] = [__v_4, __v_2, __v_3]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_667: usize = 2; -const IN_667: usize = 2; -const OUT_667: usize = 3; -fn aiur_fn_667( - inp: [G; IN_667], +const INPUT_SIZE_670: usize = 2; +const IN_670: usize = 2; +const OUT_670: usize = 3; +fn aiur_fn_670( + inp: [G; IN_670], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_667], 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]; @@ -57017,8 +57039,8 @@ fn aiur_fn_667( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_667] = [__v_2, __v_3, __v_1]; - record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_670] = [__v_2, __v_3, __v_1]; + record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57026,23 +57048,23 @@ fn aiur_fn_667( 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_667] = [__v_4, __v_2, __v_3]; - record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_670] = [__v_4, __v_2, __v_3]; + record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_668: usize = 2; -const IN_668: usize = 2; -const OUT_668: usize = 3; -fn aiur_fn_668( - inp: [G; IN_668], +const INPUT_SIZE_671: usize = 2; +const IN_671: usize = 2; +const OUT_671: usize = 3; +fn aiur_fn_671( + inp: [G; IN_671], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_668], 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]; @@ -57050,8 +57072,8 @@ fn aiur_fn_668( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_668] = [__v_2, __v_3, __v_1]; - record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_671] = [__v_2, __v_3, __v_1]; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57062,22 +57084,22 @@ fn aiur_fn_668( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_668] = [__v_4, __v_5, __v_3]; - record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_671] = [__v_4, __v_5, __v_3]; + record.function_queries[671].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_668] = [__v_4, __v_5, __v_3]; - record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_671] = [__v_4, __v_5, __v_3]; + record.function_queries[671].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_668] = [__v_4, __v_5, __v_3]; - record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_671] = [__v_4, __v_5, __v_3]; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57089,15 +57111,15 @@ fn aiur_fn_668( }) } -const INPUT_SIZE_669: usize = 2; -const IN_669: usize = 2; -const OUT_669: usize = 3; -fn aiur_fn_669( - inp: [G; IN_669], +const INPUT_SIZE_672: usize = 2; +const IN_672: usize = 2; +const OUT_672: usize = 3; +fn aiur_fn_672( + inp: [G; IN_672], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_669], 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]; @@ -57105,8 +57127,8 @@ fn aiur_fn_669( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_669] = [__v_2, __v_3, __v_1]; - record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_672] = [__v_2, __v_3, __v_1]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57117,29 +57139,29 @@ fn aiur_fn_669( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_669] = [__v_4, __v_5, __v_3]; - record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_672] = [__v_4, __v_5, __v_3]; + record.function_queries[672].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_669] = [__v_4, __v_5, __v_3]; - record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_672] = [__v_4, __v_5, __v_3]; + record.function_queries[672].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_669] = [__v_4, __v_5, __v_3]; - record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_672] = [__v_4, __v_5, __v_3]; + record.function_queries[672].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_669] = [__v_4, __v_5, __v_3]; - record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_672] = [__v_4, __v_5, __v_3]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57151,15 +57173,15 @@ fn aiur_fn_669( }) } -const INPUT_SIZE_670: usize = 9; -const IN_670: usize = 9; -const OUT_670: usize = 2; -fn aiur_fn_670( - inp: [G; IN_670], +const INPUT_SIZE_673: usize = 9; +const IN_673: usize = 9; +const OUT_673: usize = 2; +fn aiur_fn_673( + inp: [G; IN_673], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_670], 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]; @@ -57177,8 +57199,8 @@ fn aiur_fn_670( 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_670] = [__v_12, __v_0]; - record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_673] = [__v_12, __v_0]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57210,28 +57232,28 @@ fn aiur_fn_670( 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_670] = { let __args: [G; IN_670] = [__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[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_673] = { let __args: [G; IN_673] = [__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[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_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_670] = [__v_39, __v_37]; - record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_673] = [__v_39, __v_37]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_671: usize = 2; -const IN_671: usize = 2; -const OUT_671: usize = 3; -fn aiur_fn_671( - inp: [G; IN_671], +const INPUT_SIZE_674: usize = 2; +const IN_674: usize = 2; +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_671], 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]; @@ -57239,8 +57261,8 @@ fn aiur_fn_671( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_671] = [__v_2, __v_3, __v_1]; - record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_674] = [__v_2, __v_3, __v_1]; + record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57254,27 +57276,27 @@ fn aiur_fn_671( 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_670] = { let __args: [G; IN_670] = [__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[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_673] = { let __args: [G; IN_673] = [__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[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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_671] = [__v_13, __v_11, __v_12]; - record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_674] = [__v_13, __v_11, __v_12]; + record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_672: usize = 1; -const IN_672: usize = 1; -const OUT_672: usize = 41; -fn aiur_fn_672( - inp: [G; IN_672], +const INPUT_SIZE_675: usize = 1; +const IN_675: usize = 1; +const OUT_675: usize = 41; +fn aiur_fn_675( + inp: [G; IN_675], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_672], ExecError> { +) -> Result<[G; OUT_675], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -57296,11 +57318,11 @@ fn aiur_fn_672( 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_667] = { let __args: [G; IN_667] = [__v_10, __v_9]; 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_670] = { let __args: [G; IN_670] = [__v_10, __v_9]; 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 __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_665] = { let __args: [G; IN_665] = [__v_11, __v_20]; 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_668] = { let __args: [G; IN_668] = [__v_11, __v_20]; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -57311,7 +57333,7 @@ fn aiur_fn_672( 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_665] = { let __args: [G; IN_665] = [__v_12, __v_30]; 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_668] = { let __args: [G; IN_668] = [__v_12, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -57322,7 +57344,7 @@ fn aiur_fn_672( 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_665] = { let __args: [G; IN_665] = [__v_13, __v_40]; 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_668] = { let __args: [G; IN_668] = [__v_13, __v_40]; 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_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -57333,7 +57355,7 @@ fn aiur_fn_672( 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_665] = { let __args: [G; IN_665] = [__v_14, __v_50]; 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_668] = { let __args: [G; IN_668] = [__v_14, __v_50]; 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_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -57344,25 +57366,25 @@ fn aiur_fn_672( 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_666] = { let __args: [G; IN_666] = [__v_15, __v_60]; 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_669] = { let __args: [G; IN_669] = [__v_15, __v_60]; 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_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __ret: [G; OUT_672] = [__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[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_675] = [__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[675].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 = 49; -fn aiur_fn_673( - inp: [G; IN_673], +const INPUT_SIZE_676: usize = 1; +const IN_676: usize = 1; +const OUT_676: usize = 49; +fn aiur_fn_676( + inp: [G; IN_676], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_673], ExecError> { +) -> Result<[G; OUT_676], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -57375,7 +57397,7 @@ fn aiur_fn_673( 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_672] = { let __args: [G; IN_672] = [__v_9]; 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 __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57417,21 +57439,21 @@ fn aiur_fn_673( 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_673] = [__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[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_676] = [__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[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_674: usize = 9; -const IN_674: usize = 9; -const OUT_674: usize = 2; -fn aiur_fn_674( - inp: [G; IN_674], +const INPUT_SIZE_677: usize = 9; +const IN_677: usize = 9; +const OUT_677: usize = 2; +fn aiur_fn_677( + inp: [G; IN_677], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_674], 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]; @@ -57449,12 +57471,12 @@ fn aiur_fn_674( 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_674] = [__v_12, __v_0]; - record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_677] = [__v_12, __v_0]; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_0]; 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_676] = { let __args: [G; IN_676] = [__v_0]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57513,28 +57535,28 @@ fn aiur_fn_674( 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_674] = { let __args: [G; IN_674] = [__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[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_677] = { let __args: [G; IN_677] = [__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[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_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_674] = [__v_70, __v_68]; - record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_677] = [__v_70, __v_68]; + record.function_queries[677].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_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_675], 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]; @@ -57542,8 +57564,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_678] = [__v_2, __v_3, __v_1]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57557,27 +57579,27 @@ fn aiur_fn_675( 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_674] = { let __args: [G; IN_674] = [__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[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_677] = { let __args: [G; IN_677] = [__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[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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_675] = [__v_13, __v_11, __v_12]; - record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_678] = [__v_13, __v_11, __v_12]; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_676: usize = 1; -const IN_676: usize = 1; -const OUT_676: usize = 55; -fn aiur_fn_676( - inp: [G; IN_676], +const INPUT_SIZE_679: usize = 1; +const IN_679: usize = 1; +const OUT_679: usize = 55; +fn aiur_fn_679( + inp: [G; IN_679], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_676], ExecError> { +) -> Result<[G; OUT_679], 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)? } }; @@ -57613,15 +57635,15 @@ fn aiur_fn_676( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; 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_671] = { let __args: [G; IN_671] = [__v_12, __v_11]; 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 __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_668] = { let __args: [G; IN_668] = [__v_13, __v_30]; 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_671] = { let __args: [G; IN_671] = [__v_13, __v_30]; 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 __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_665] = { let __args: [G; IN_665] = [__v_14, __v_33]; 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_668] = { let __args: [G; IN_668] = [__v_14, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -57632,101 +57654,82 @@ fn aiur_fn_676( 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_666] = { let __args: [G; IN_666] = [__v_15, __v_43]; 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_669] = { let __args: [G; IN_669] = [__v_15, __v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_16, __v_46]; 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_669] = { let __args: [G; IN_669] = [__v_16, __v_46]; 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_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_676] = [__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[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_12, __v_11]; 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_670] = { let __args: [G; IN_670] = [__v_12, __v_11]; 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 __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_667] = { let __args: [G; IN_667] = [__v_13, __v_30]; 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_13, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_14, __v_33]; 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_34: G = __r_arr[0]; - let __v_35: G = __r_arr[1]; - let __v_36: G = __r_arr[2]; - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_15, __v_36]; 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_37: G = __r_arr[0]; - let __v_38: G = __r_arr[1]; - let __v_39: G = __r_arr[2]; - let __v_40: G = __r_arr[3]; - let __v_41: G = __r_arr[4]; - let __v_42: G = __r_arr[5]; - let __v_43: G = __r_arr[6]; - let __v_44: G = __r_arr[7]; - let __v_45: G = __r_arr[8]; - let __v_46: G = __r_arr[9]; - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_16, __v_46]; 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_47: G = __r_arr[0]; - let __v_48: G = __r_arr[1]; - let __v_49: G = __r_arr[2]; - let __v_50: G = __r_arr[3]; - let __v_51: G = __r_arr[4]; - let __v_52: G = __r_arr[5]; - let __v_53: G = __r_arr[6]; - let __v_54: G = __r_arr[7]; - let __v_55: G = __r_arr[8]; - let __v_56: G = __r_arr[9]; - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_17, __v_56]; 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_57: G = __r_arr[0]; - let __v_58: G = __r_arr[1]; - let __v_59: G = __r_arr[2]; - let __v_60: G = __r_arr[3]; - let __v_61: G = __r_arr[4]; - let __v_62: G = __r_arr[5]; - let __v_63: G = __r_arr[6]; - let __v_64: G = __r_arr[7]; - let __v_65: G = __r_arr[8]; - let __v_66: G = __r_arr[9]; - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_18, __v_66]; 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_67: G = __r_arr[0]; - let __v_68: G = __r_arr[1]; - let __v_69: G = __r_arr[2]; - let __v_70: G = __r_arr[3]; - let __v_71: G = __r_arr[4]; - let __v_72: G = __r_arr[5]; - let __v_73: G = __r_arr[6]; - let __v_74: G = __r_arr[7]; - let __v_75: G = __r_arr[8]; - let __v_76: G = __r_arr[9]; - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_19, __v_76]; 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_77: G = __r_arr[0]; - let __v_78: G = __r_arr[1]; - let __v_79: G = __r_arr[2]; - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_20, __v_79]; 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_80: G = __r_arr[0]; - let __v_81: G = __r_arr[1]; - let __v_82: G = __r_arr[2]; - let __v_83: G = G::from_u64(1); - let __v_84: G = G::from_u64(0); - let __ret: [G; OUT_676] = [__v_83, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_37, __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_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_77, __v_78, __v_80, __v_81, __v_84, __v_84, __v_84, __v_84, __v_84, __v_84, __v_84, __v_82]; - record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = __r_arr[9]; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_14, __v_40]; 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_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __v_43: G = __r_arr[2]; + let __v_44: G = __r_arr[3]; + let __v_45: G = __r_arr[4]; + let __v_46: G = __r_arr[5]; + let __v_47: G = __r_arr[6]; + let __v_48: G = __r_arr[7]; + let __v_49: G = __r_arr[8]; + let __v_50: G = __r_arr[9]; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_15, __v_50]; 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_51: G = __r_arr[0]; + let __v_52: G = __r_arr[1]; + let __v_53: G = __r_arr[2]; + let __v_54: G = __r_arr[3]; + let __v_55: G = __r_arr[4]; + let __v_56: G = __r_arr[5]; + let __v_57: G = __r_arr[6]; + let __v_58: G = __r_arr[7]; + let __v_59: G = __r_arr[8]; + let __v_60: G = __r_arr[9]; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_16, __v_60]; 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_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_17, __v_63]; 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_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_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_12, __v_11]; 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_670] = { let __args: [G; IN_670] = [__v_12, __v_11]; 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 __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_667] = { let __args: [G; IN_667] = [__v_13, __v_30]; 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_670] = { let __args: [G; IN_670] = [__v_13, __v_30]; 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 __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_665] = { let __args: [G; IN_665] = [__v_14, __v_33]; 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_668] = { let __args: [G; IN_668] = [__v_14, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -57737,7 +57740,7 @@ fn aiur_fn_676( 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_665] = { let __args: [G; IN_665] = [__v_15, __v_43]; 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_668] = { let __args: [G; IN_668] = [__v_15, __v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -57748,7 +57751,7 @@ fn aiur_fn_676( 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_665] = { let __args: [G; IN_665] = [__v_16, __v_53]; 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_668] = { let __args: [G; IN_668] = [__v_16, __v_53]; 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_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -57759,7 +57762,7 @@ fn aiur_fn_676( 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_665] = { let __args: [G; IN_665] = [__v_17, __v_63]; 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_668] = { let __args: [G; IN_668] = [__v_17, __v_63]; 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_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -57770,7 +57773,7 @@ fn aiur_fn_676( 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_665] = { let __args: [G; IN_665] = [__v_18, __v_73]; 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_668] = { let __args: [G; IN_668] = [__v_18, __v_73]; 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_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -57781,17 +57784,17 @@ fn aiur_fn_676( 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_666] = { let __args: [G; IN_666] = [__v_19, __v_83]; 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_669] = { let __args: [G; IN_669] = [__v_19, __v_83]; 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_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_20, __v_86]; 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 __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_20, __v_86]; 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_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_676] = [__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[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -57801,15 +57804,15 @@ fn aiur_fn_676( }) } -const INPUT_SIZE_677: usize = 1; -const IN_677: usize = 1; -const OUT_677: usize = 63; -fn aiur_fn_677( - inp: [G; IN_677], +const INPUT_SIZE_680: usize = 1; +const IN_680: usize = 1; +const OUT_680: usize = 63; +fn aiur_fn_680( + inp: [G; IN_680], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_677], ExecError> { +) -> Result<[G; OUT_680], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -57822,7 +57825,7 @@ fn aiur_fn_677( 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_676] = { let __args: [G; IN_676] = [__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_679] = { let __args: [G; IN_679] = [__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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57878,21 +57881,21 @@ fn aiur_fn_677( 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_677] = [__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[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_680] = [__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[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_678: usize = 9; -const IN_678: usize = 9; -const OUT_678: usize = 2; -fn aiur_fn_678( - inp: [G; IN_678], +const INPUT_SIZE_681: usize = 9; +const IN_681: usize = 9; +const OUT_681: usize = 2; +fn aiur_fn_681( + inp: [G; IN_681], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_678], 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]; @@ -57910,12 +57913,12 @@ fn aiur_fn_678( 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_678] = [__v_12, __v_0]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_681] = [__v_12, __v_0]; + record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0]; 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_680] = { let __args: [G; IN_680] = [__v_0]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57988,28 +57991,28 @@ fn aiur_fn_678( 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_678] = { let __args: [G; IN_678] = [__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[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_681] = { let __args: [G; IN_681] = [__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[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_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_678] = [__v_84, __v_82]; - record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_681] = [__v_84, __v_82]; + record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_679: usize = 1; -const IN_679: usize = 1; -const OUT_679: usize = 55; -fn aiur_fn_679( - inp: [G; IN_679], +const INPUT_SIZE_682: usize = 1; +const IN_682: usize = 1; +const OUT_682: usize = 55; +fn aiur_fn_682( + inp: [G; IN_682], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_679], 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)? } }; @@ -58045,15 +58048,15 @@ fn aiur_fn_679( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; 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_671] = { let __args: [G; IN_671] = [__v_12, __v_11]; 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 __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_668] = { let __args: [G; IN_668] = [__v_13, __v_30]; 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_671] = { let __args: [G; IN_671] = [__v_13, __v_30]; 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 __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_665] = { let __args: [G; IN_665] = [__v_14, __v_33]; 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_668] = { let __args: [G; IN_668] = [__v_14, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -58064,30 +58067,30 @@ fn aiur_fn_679( 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_666] = { let __args: [G; IN_666] = [__v_15, __v_43]; 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_669] = { let __args: [G; IN_669] = [__v_15, __v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_16, __v_46]; 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_669] = { let __args: [G; IN_669] = [__v_16, __v_46]; 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_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_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_12, __v_11]; 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_670] = { let __args: [G; IN_670] = [__v_12, __v_11]; 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 __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_667] = { let __args: [G; IN_667] = [__v_13, __v_30]; 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_670] = { let __args: [G; IN_670] = [__v_13, __v_30]; 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 __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_665] = { let __args: [G; IN_665] = [__v_14, __v_33]; 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_668] = { let __args: [G; IN_668] = [__v_14, __v_33]; 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_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -58098,7 +58101,7 @@ fn aiur_fn_679( 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_665] = { let __args: [G; IN_665] = [__v_15, __v_43]; 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_668] = { let __args: [G; IN_668] = [__v_15, __v_43]; 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_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -58109,7 +58112,7 @@ fn aiur_fn_679( 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_665] = { let __args: [G; IN_665] = [__v_16, __v_53]; 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_668] = { let __args: [G; IN_668] = [__v_16, __v_53]; 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_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -58120,7 +58123,7 @@ fn aiur_fn_679( 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_665] = { let __args: [G; IN_665] = [__v_17, __v_63]; 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_668] = { let __args: [G; IN_668] = [__v_17, __v_63]; 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_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -58131,7 +58134,7 @@ fn aiur_fn_679( 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_665] = { let __args: [G; IN_665] = [__v_18, __v_73]; 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_668] = { let __args: [G; IN_668] = [__v_18, __v_73]; 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_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -58142,25 +58145,25 @@ fn aiur_fn_679( 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_666] = { let __args: [G; IN_666] = [__v_19, __v_83]; 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_669] = { let __args: [G; IN_669] = [__v_19, __v_83]; 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_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_20, __v_86]; 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 __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_20, __v_86]; 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_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_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_12, __v_11]; 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_670] = { let __args: [G; IN_670] = [__v_12, __v_11]; 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 __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_665] = { let __args: [G; IN_665] = [__v_13, __v_30]; 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_668] = { let __args: [G; IN_668] = [__v_13, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -58171,22 +58174,22 @@ fn aiur_fn_679( 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_666] = { let __args: [G; IN_666] = [__v_14, __v_40]; 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_669] = { let __args: [G; IN_669] = [__v_14, __v_40]; 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_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_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_12, __v_11]; 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_672] = { let __args: [G; IN_672] = [__v_12, __v_11]; 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 __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_665] = { let __args: [G; IN_665] = [__v_13, __v_30]; 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_668] = { let __args: [G; IN_668] = [__v_13, __v_30]; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -58197,18 +58200,18 @@ fn aiur_fn_679( 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_666] = { let __args: [G; IN_666] = [__v_14, __v_40]; 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_669] = { let __args: [G; IN_669] = [__v_14, __v_40]; 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_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_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_12, __v_11]; 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_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -58219,7 +58222,7 @@ fn aiur_fn_679( 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_665] = { let __args: [G; IN_665] = [__v_13, __v_37]; 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_668] = { let __args: [G; IN_668] = [__v_13, __v_37]; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -58230,18 +58233,18 @@ fn aiur_fn_679( 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_14, __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_669] = { let __args: [G; IN_669] = [__v_14, __v_47]; 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_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_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_12, __v_11]; 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_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -58252,18 +58255,18 @@ fn aiur_fn_679( 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_666] = { let __args: [G; IN_666] = [__v_13, __v_37]; 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_669] = { let __args: [G; IN_669] = [__v_13, __v_37]; 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_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_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_12, __v_11]; 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_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -58274,18 +58277,18 @@ fn aiur_fn_679( 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_666] = { let __args: [G; IN_666] = [__v_13, __v_37]; 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_669] = { let __args: [G; IN_669] = [__v_13, __v_37]; 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_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_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_12, __v_11]; 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_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -58296,14 +58299,14 @@ fn aiur_fn_679( 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_666] = { let __args: [G; IN_666] = [__v_13, __v_37]; 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_669] = { let __args: [G; IN_669] = [__v_13, __v_37]; 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_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_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { @@ -58325,7 +58328,7 @@ fn aiur_fn_679( 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_678] = { let __args: [G; IN_678] = [__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[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_681] = { let __args: [G; IN_681] = [__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[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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -58339,8 +58342,8 @@ fn aiur_fn_679( 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_679] = [__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[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_682] = [__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[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58350,15 +58353,15 @@ fn aiur_fn_679( }) } -const INPUT_SIZE_680: usize = 1; -const IN_680: usize = 1; -const OUT_680: usize = 57; -fn aiur_fn_680( - inp: [G; IN_680], +const INPUT_SIZE_683: usize = 1; +const IN_683: usize = 1; +const OUT_683: usize = 57; +fn aiur_fn_683( + inp: [G; IN_683], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_680], 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; @@ -58384,49 +58387,49 @@ fn aiur_fn_680( let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_15]; 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_667] = { let __args: [G; IN_667] = [__v_15]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_680] = [__v_19, __v_12, __v_14, __v_16, __v_17, __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_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_18]; - record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_683] = [__v_19, __v_12, __v_14, __v_16, __v_17, __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_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_18]; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_13]; 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_667] = { let __args: [G; IN_667] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_680] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; - record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_683] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_13]; 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_667] = { let __args: [G; IN_667] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = G::from_u64(2); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_680] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; - record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_683] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_13]; 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_682] = { let __args: [G; IN_682] = [__v_13]; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -58483,8 +58486,8 @@ fn aiur_fn_680( let __v_67: G = __r_arr[53]; let __v_68: G = __r_arr[54]; let __v_69: G = G::from_u64(3); - let __ret: [G; OUT_680] = [__v_69, __v_12, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __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]; - record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_683] = [__v_69, __v_12, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __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]; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { @@ -58496,8 +58499,8 @@ fn aiur_fn_680( let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(4); let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_680] = [__v_16, __v_12, __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_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[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_683] = [__v_16, __v_12, __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_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[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58507,15 +58510,15 @@ fn aiur_fn_680( }) } -const INPUT_SIZE_681: usize = 32; -const IN_681: usize = 32; -const OUT_681: usize = 56; -fn aiur_fn_681( - inp: [G; IN_681], +const INPUT_SIZE_684: usize = 32; +const IN_684: usize = 32; +const OUT_684: usize = 56; +fn aiur_fn_684( + inp: [G; IN_684], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_681], 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]; @@ -58557,7 +58560,7 @@ fn aiur_fn_681( let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_35, __v_33, __v_34]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_36, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[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 __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_36]; 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_683] = { let __args: [G; IN_683] = [__v_36]; 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_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -58630,21 +58633,21 @@ fn aiur_fn_681( if (__v_96 != __v_98) { return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_98.as_canonical_u64() }); } - let __ret: [G; OUT_681] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92]; - record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_684] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92]; + record.function_queries[684].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 = 1; -fn aiur_fn_682( - inp: [G; IN_682], +const INPUT_SIZE_685: usize = 1; +const IN_685: usize = 1; +const OUT_685: usize = 1; +fn aiur_fn_685( + inp: [G; IN_685], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_682], ExecError> { +) -> Result<[G; OUT_685], 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 }; @@ -58673,40 +58676,40 @@ fn aiur_fn_682( let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_682] = [__v_23]; - record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_685] = [__v_23]; + record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_683: usize = 1; -const IN_683: usize = 1; -const OUT_683: usize = 1; -fn aiur_fn_683( - inp: [G; IN_683], +const INPUT_SIZE_686: usize = 1; +const IN_686: usize = 1; +const OUT_686: usize = 1; +fn aiur_fn_686( + inp: [G; IN_686], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_683], ExecError> { +) -> Result<[G; OUT_686], 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_683] = [__v_1]; - record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_686] = [__v_1]; + record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_683] = [__v_1]; - record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_686] = [__v_1]; + record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_683] = [__v_1]; - record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_686] = [__v_1]; + record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58716,35 +58719,35 @@ fn aiur_fn_683( }) } -const INPUT_SIZE_684: usize = 3; -const IN_684: usize = 3; -const OUT_684: usize = 0; -fn aiur_fn_684( - inp: [G; IN_684], +const INPUT_SIZE_687: usize = 3; +const IN_687: usize = 3; +const OUT_687: usize = 0; +fn aiur_fn_687( + inp: [G; IN_687], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_684], ExecError> { +) -> Result<[G; OUT_687], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_684] = []; - record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_687] = []; + record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - 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_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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_2]; 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_686] = { let __args: [G; IN_686] = [__v_2]; 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_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() }); } - let __ret: [G; OUT_684] = []; - record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_687] = []; + record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58754,23 +58757,23 @@ fn aiur_fn_684( }) } -const INPUT_SIZE_685: usize = 3; -const IN_685: usize = 3; -const OUT_685: usize = 0; -fn aiur_fn_685( - inp: [G; IN_685], +const INPUT_SIZE_688: usize = 3; +const IN_688: usize = 3; +const OUT_688: usize = 0; +fn aiur_fn_688( + inp: [G; IN_688], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_685], ExecError> { +) -> Result<[G; OUT_688], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_685] = []; - record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = []; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -58781,8 +58784,8 @@ fn aiur_fn_685( if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); } - let __ret: [G; OUT_685] = []; - record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_688] = []; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58792,31 +58795,31 @@ fn aiur_fn_685( }) } -const INPUT_SIZE_686: usize = 3; -const IN_686: usize = 3; -const OUT_686: usize = 0; -fn aiur_fn_686( - inp: [G; IN_686], +const INPUT_SIZE_689: usize = 3; +const IN_689: usize = 3; +const OUT_689: usize = 0; +fn aiur_fn_689( + inp: [G; IN_689], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_686], ExecError> { +) -> Result<[G; OUT_689], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_686] = []; - record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = []; + record.function_queries[689].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() }); } - let __ret: [G; OUT_686] = []; - record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_689] = []; + record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58826,15 +58829,15 @@ fn aiur_fn_686( }) } -const INPUT_SIZE_687: usize = 17; -const IN_687: usize = 17; -const OUT_687: usize = 0; -fn aiur_fn_687( - inp: [G; IN_687], +const INPUT_SIZE_690: usize = 17; +const IN_690: usize = 17; +const OUT_690: usize = 0; +fn aiur_fn_690( + inp: [G; IN_690], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_687], ExecError> { +) -> Result<[G; OUT_690], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58855,8 +58858,8 @@ fn aiur_fn_687( let __v_16: G = inp[16]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_687] = []; - record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_690] = []; + record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -58884,8 +58887,8 @@ fn aiur_fn_687( if (__v_7 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); } - let __ret: [G; OUT_687] = []; - record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_690] = []; + record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -58895,23 +58898,23 @@ fn aiur_fn_687( }) } -const INPUT_SIZE_688: usize = 3; -const IN_688: usize = 3; -const OUT_688: usize = 0; -fn aiur_fn_688( - inp: [G; IN_688], +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_688], ExecError> { +) -> Result<[G; OUT_691], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_688] = []; - record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_691] = []; + record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -59077,8 +59080,8 @@ fn aiur_fn_688( if (__v_34 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64() }); } - let __ret: [G; OUT_688] = []; - record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_691] = []; + record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59088,27 +59091,27 @@ fn aiur_fn_688( }) } -const INPUT_SIZE_689: usize = 3; -const IN_689: usize = 3; -const OUT_689: usize = 0; -fn aiur_fn_689( - inp: [G; IN_689], +const INPUT_SIZE_692: usize = 3; +const IN_692: usize = 3; +const OUT_692: usize = 0; +fn aiur_fn_692( + inp: [G; IN_692], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_689], ExecError> { +) -> Result<[G; OUT_692], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_689] = []; - record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_692] = []; + record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - 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_685] = { let __args: [G; IN_685] = [__v_0]; 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_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]; @@ -59272,8 +59275,8 @@ fn aiur_fn_689( if (__v_35 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64() }); } - let __ret: [G; OUT_689] = []; - record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_692] = []; + record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59283,15 +59286,15 @@ fn aiur_fn_689( }) } -const INPUT_SIZE_690: usize = 2; -const IN_690: usize = 2; -const OUT_690: usize = 0; -fn aiur_fn_690( - inp: [G; IN_690], +const INPUT_SIZE_693: usize = 2; +const IN_693: usize = 2; +const OUT_693: usize = 0; +fn aiur_fn_693( + inp: [G; IN_693], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_690], ExecError> { +) -> Result<[G; OUT_693], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59331,8 +59334,8 @@ fn aiur_fn_690( let __v_31: G = __loaded[10]; match __v_21.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_690] = []; - record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_693] = []; + record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59384,10 +59387,10 @@ fn aiur_fn_690( return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); } let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_30, __v_32, __v_19]; 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_31, __v_20]; 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 __ret: [G; OUT_690] = []; - record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_30, __v_32, __v_19]; 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_31, __v_20]; 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 __ret: [G; OUT_693] = []; + record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -59406,29 +59409,29 @@ fn aiur_fn_690( }) } -const INPUT_SIZE_691: usize = 3; -const IN_691: usize = 3; -const OUT_691: usize = 0; -fn aiur_fn_691( - inp: [G; IN_691], +const INPUT_SIZE_694: usize = 3; +const IN_694: usize = 3; +const OUT_694: usize = 0; +fn aiur_fn_694( + inp: [G; IN_694], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_691], ExecError> { +) -> Result<[G; OUT_694], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_691] = []; - record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_694] = []; + record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __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 __ret: [G; OUT_691] = []; - record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0, __v_2]; 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 __ret: [G; OUT_694] = []; + record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59438,15 +59441,15 @@ fn aiur_fn_691( }) } -const INPUT_SIZE_692: usize = 49; -const IN_692: usize = 49; -const OUT_692: usize = 0; -fn aiur_fn_692( - inp: [G; IN_692], +const INPUT_SIZE_695: usize = 49; +const IN_695: usize = 49; +const OUT_695: usize = 0; +fn aiur_fn_695( + inp: [G; IN_695], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_692], ExecError> { +) -> Result<[G; OUT_695], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59497,7 +59500,7 @@ fn aiur_fn_692( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - 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, __v_8]; 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_738] = { let __args: [G; IN_738] = [__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[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; @@ -59536,14 +59539,14 @@ fn aiur_fn_692( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_49, __v_9, __v_10]; 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_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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_82, __v_47, __v_48]; 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 __ret: [G; OUT_692] = []; - record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_49, __v_9, __v_10]; 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_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[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_690] = { let __args: [G; IN_690] = [__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[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_690] = { let __args: [G; IN_690] = [__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[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_690] = { let __args: [G; IN_690] = [__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[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_692] = { let __args: [G; IN_692] = [__v_82, __v_47, __v_48]; 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 __ret: [G; OUT_695] = []; + record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -59552,15 +59555,15 @@ fn aiur_fn_692( }) } -const INPUT_SIZE_693: usize = 2; -const IN_693: usize = 2; -const OUT_693: usize = 0; -fn aiur_fn_693( - inp: [G; IN_693], +const INPUT_SIZE_696: usize = 2; +const IN_696: usize = 2; +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_693], 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]; @@ -59617,15 +59620,15 @@ fn aiur_fn_693( let __v_51: G = __loaded[49]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_693] = []; - record.function_queries[693].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 => { - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__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[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_0, __v_51]; 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 __ret: [G; OUT_693] = []; - record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__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[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_0, __v_51]; 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_696] = []; + record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59635,29 +59638,29 @@ fn aiur_fn_693( }) } -const INPUT_SIZE_694: usize = 3; -const IN_694: usize = 3; -const OUT_694: usize = 0; -fn aiur_fn_694( - inp: [G; IN_694], +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_694], 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_694] = []; - record.function_queries[694].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 => { - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0, __v_2]; 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 __ret: [G; OUT_694] = []; - record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_0, __v_2]; 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_697] = []; + record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -59667,15 +59670,15 @@ fn aiur_fn_694( }) } -const INPUT_SIZE_695: usize = 99; -const IN_695: usize = 99; -const OUT_695: usize = 0; -fn aiur_fn_695( - inp: [G; IN_695], +const INPUT_SIZE_698: usize = 99; +const IN_698: usize = 99; +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_695], 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]; @@ -59782,13 +59785,13 @@ fn aiur_fn_695( 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_1, __v_46, __v_47]; 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_684] = { let __args: [G; IN_684] = [__v_2, __v_48, __v_49]; 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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_11, __v_59, __v_60]; 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_689] = { let __args: [G; IN_689] = [__v_12, __v_61, __v_62]; 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 __ret: [G; OUT_695] = []; - record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_1, __v_46, __v_47]; 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_687] = { let __args: [G; IN_687] = [__v_2, __v_48, __v_49]; 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_690] = { let __args: [G; IN_690] = [__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[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_692] = { let __args: [G; IN_692] = [__v_11, __v_59, __v_60]; 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_692] = { let __args: [G; IN_692] = [__v_12, __v_61, __v_62]; 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 __ret: [G; OUT_698] = []; + record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -59803,17 +59806,14 @@ fn aiur_fn_695( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_1, __v_46, __v_47]; 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_686] = { let __args: [G; IN_686] = [__v_2, __v_48, __v_49]; 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_686] = { let __args: [G; IN_686] = [__v_3, __v_50, __v_51]; 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_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; 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_687] = { let __args: [G; IN_687] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69]; 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_687] = { let __args: [G; IN_687] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78]; 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_687] = { let __args: [G; IN_687] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; 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_689] = { let __args: [G; IN_689] = [__v_36, __v_88, __v_89]; 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_694] = { let __args: [G; IN_694] = [__v_37, __v_90, __v_91]; 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 __ret: [G; OUT_695] = []; - record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_1, __v_46, __v_47]; 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_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[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_690] = { let __args: [G; IN_690] = [__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[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_690] = { let __args: [G; IN_690] = [__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[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_692] = { let __args: [G; IN_692] = [__v_26, __v_75, __v_76]; 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_697] = { let __args: [G; IN_697] = [__v_27, __v_77, __v_78]; 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_698] = []; + record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -59828,17 +59828,17 @@ fn aiur_fn_695( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_1, __v_46, __v_47]; 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_686] = { let __args: [G; IN_686] = [__v_2, __v_48, __v_49]; 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_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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_43, __v_95, __v_96]; 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_691] = { let __args: [G; IN_691] = [__v_44, __v_97, __v_98]; 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 __ret: [G; OUT_695] = []; - record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_1, __v_46, __v_47]; 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_689] = { let __args: [G; IN_689] = [__v_2, __v_48, __v_49]; 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_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[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_690] = { let __args: [G; IN_690] = [__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[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_690] = { let __args: [G; IN_690] = [__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[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_690] = { let __args: [G; IN_690] = [__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[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_690] = { let __args: [G; IN_690] = [__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[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_692] = { let __args: [G; IN_692] = [__v_43, __v_95, __v_96]; 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_694] = { let __args: [G; IN_694] = [__v_44, __v_97, __v_98]; 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 __ret: [G; OUT_698] = []; + record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -59855,15 +59855,15 @@ fn aiur_fn_695( }) } -const INPUT_SIZE_696: usize = 2; -const IN_696: usize = 2; -const OUT_696: usize = 0; -fn aiur_fn_696( - inp: [G; IN_696], +const INPUT_SIZE_699: usize = 2; +const IN_699: usize = 2; +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_696], 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]; @@ -59934,12 +59934,12 @@ fn aiur_fn_696( let __v_65: G = __loaded[63]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_696] = []; - record.function_queries[696].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); }, 0u64 => { - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__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[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_733] = { let __args: [G; IN_733] = [__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[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_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -59985,10 +59985,10 @@ fn aiur_fn_696( 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_695] = { let __args: [G; IN_695] = [__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[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_0, __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 __ret: [G; OUT_696] = []; - record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__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[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_699] = { let __args: [G; IN_699] = [__v_0, __v_65]; 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); }, _ => { @@ -59998,15 +59998,15 @@ fn aiur_fn_696( }) } -const INPUT_SIZE_697: usize = 1; -const IN_697: usize = 1; -const OUT_697: usize = 1; -fn aiur_fn_697( - inp: [G; IN_697], +const INPUT_SIZE_700: usize = 1; +const IN_700: usize = 1; +const OUT_700: usize = 1; +fn aiur_fn_700( + inp: [G; IN_700], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_697], ExecError> { +) -> Result<[G; OUT_700], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); @@ -60019,21 +60019,21 @@ fn aiur_fn_697( 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_19] = { let __args: [G; IN_19] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_697] = [__v_8]; - record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_700] = [__v_8]; + record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_698: usize = 2; -const IN_698: usize = 2; -const OUT_698: usize = 1; -fn aiur_fn_698( - inp: [G; IN_698], +const INPUT_SIZE_701: usize = 2; +const IN_701: usize = 2; +const OUT_701: usize = 1; +fn aiur_fn_701( + inp: [G; IN_701], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_698], 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]; @@ -60049,21 +60049,21 @@ fn aiur_fn_698( 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_19] = { let __args: [G; IN_19] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_698] = [__v_10]; - record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_701] = [__v_10]; + record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_699: usize = 1; -const IN_699: usize = 1; -const OUT_699: usize = 3; -fn aiur_fn_699( - inp: [G; IN_699], +const INPUT_SIZE_702: usize = 1; +const IN_702: usize = 1; +const OUT_702: usize = 3; +fn aiur_fn_702( + inp: [G; IN_702], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_699], ExecError> { +) -> Result<[G; OUT_702], 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)? } }; @@ -60074,15 +60074,15 @@ fn aiur_fn_699( let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_3]; 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_700] = { let __args: [G; IN_700] = [__v_3]; 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 __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_699] = [__v_5, __v_10, __v_4]; - record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_702] = [__v_5, __v_10, __v_4]; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -60122,25 +60122,25 @@ fn aiur_fn_699( 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_699] = [__v_35, __v_38, __v_2]; - record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_702] = [__v_35, __v_38, __v_2]; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; 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 __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__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 __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_699] = { let __args: [G; IN_699] = [__v_5]; 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 __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_5]; 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 __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_698] = { let __args: [G; IN_698] = [__v_3, __v_6]; 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_701] = { let __args: [G; IN_701] = [__v_3, __v_6]; 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 __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_4, __v_7]; 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_724] = { let __args: [G; IN_724] = [__v_4, __v_7]; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_9, __v_10, __v_8]; - record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_702] = [__v_9, __v_10, __v_8]; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60150,15 +60150,15 @@ fn aiur_fn_699( }) } -const INPUT_SIZE_700: usize = 1; -const IN_700: usize = 1; -const OUT_700: usize = 1; -fn aiur_fn_700( - inp: [G; IN_700], +const INPUT_SIZE_703: usize = 1; +const IN_703: usize = 1; +const OUT_703: usize = 1; +fn aiur_fn_703( + inp: [G; IN_703], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_700], ExecError> { +) -> Result<[G; OUT_703], 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 }; @@ -60220,7 +60220,7 @@ fn aiur_fn_700( if (__v_39 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_49.as_canonical_u64() }); } - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_47]; 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 __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -60368,21 +60368,21 @@ fn aiur_fn_700( if (__v_89 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_32.as_canonical_u64() }); } - let __ret: [G; OUT_700] = [__v_51]; - record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_703] = [__v_51]; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_701: usize = 2; -const IN_701: usize = 2; -const OUT_701: usize = 1; -fn aiur_fn_701( - inp: [G; IN_701], +const INPUT_SIZE_704: usize = 2; +const IN_704: usize = 2; +const OUT_704: usize = 1; +fn aiur_fn_704( + inp: [G; IN_704], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_701], 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]; @@ -60393,8 +60393,8 @@ fn aiur_fn_701( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_701] = [__v_5]; - record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_704] = [__v_5]; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -60403,15 +60403,15 @@ fn aiur_fn_701( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_701] = [__v_6]; - record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_704] = [__v_6]; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_0, __v_4]; 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_704] = { let __args: [G; IN_704] = [__v_0, __v_4]; 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 __v_6: G = __r_arr[0]; - let __ret: [G; OUT_701] = [__v_6]; - record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_704] = [__v_6]; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60423,15 +60423,15 @@ fn aiur_fn_701( }) } -const INPUT_SIZE_702: usize = 1; -const IN_702: usize = 1; -const OUT_702: usize = 1; -fn aiur_fn_702( - inp: [G; IN_702], +const INPUT_SIZE_705: usize = 1; +const IN_705: usize = 1; +const OUT_705: usize = 1; +fn aiur_fn_705( + inp: [G; IN_705], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_702], ExecError> { +) -> Result<[G; OUT_705], 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 }; @@ -60476,21 +60476,21 @@ fn aiur_fn_702( let __v_39: G = (__v_36 + __v_38); let __v_40: G = (__v_34 + __v_39); let __v_41: G = (__v_1 + __v_40); - let __ret: [G; OUT_702] = [__v_41]; - record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_705] = [__v_41]; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_703: usize = 7; -const IN_703: usize = 7; -const OUT_703: usize = 6; -fn aiur_fn_703( - inp: [G; IN_703], +const INPUT_SIZE_706: usize = 7; +const IN_706: usize = 7; +const OUT_706: usize = 6; +fn aiur_fn_706( + inp: [G; IN_706], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_703], 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]; @@ -60505,29 +60505,29 @@ fn aiur_fn_703( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_703] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; - record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_706] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_8]; 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 __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_8]; 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 __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_10, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_10, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; let __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_703] = { let __args: [G; IN_703] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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_706] = { let __args: [G; IN_706] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 __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_703] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_706] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60537,15 +60537,15 @@ fn aiur_fn_703( }) } -const INPUT_SIZE_704: usize = 7; -const IN_704: usize = 7; -const OUT_704: usize = 1; -fn aiur_fn_704( - inp: [G; IN_704], +const INPUT_SIZE_707: usize = 7; +const IN_707: usize = 7; +const OUT_707: usize = 1; +fn aiur_fn_707( + inp: [G; IN_707], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_704], 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]; @@ -60554,7 +60554,7 @@ fn aiur_fn_704( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_0]; 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 __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_0]; 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 __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); @@ -60589,34 +60589,34 @@ fn aiur_fn_704( 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 __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_40]; 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_726] = { let __args: [G; IN_726] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_40]; 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_41: G = __r_arr[0]; let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_41, __v_0]; 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_42: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_42]; - record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_707] = [__v_42]; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_705: usize = 4; -const IN_705: usize = 4; -const OUT_705: usize = 0; -fn aiur_fn_705( - inp: [G; IN_705], +const INPUT_SIZE_708: usize = 4; +const IN_708: usize = 4; +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_705], 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]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_1]; 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_635] = { let __args: [G; IN_635] = [__v_1]; 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 = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; 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_706] = { let __args: [G; IN_706] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; 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 __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -60624,22 +60624,22 @@ fn aiur_fn_705( let __v_10: G = __r_arr[4]; let __v_11: G = __r_arr[5]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_705] = []; - record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 __ret: [G; OUT_708] = []; + record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_706: usize = 10; -const IN_706: usize = 10; -const OUT_706: usize = 0; -fn aiur_fn_706( - inp: [G; IN_706], +const INPUT_SIZE_709: usize = 10; +const IN_709: usize = 10; +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_706], 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]; @@ -60657,8 +60657,8 @@ fn aiur_fn_706( let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_709] = []; + record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -60674,26 +60674,26 @@ fn aiur_fn_706( let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; let __v_23: G = __loaded[10]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_9]; 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_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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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_707] = { let __args: [G; IN_707] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 __v_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __ret: [G; OUT_709] = []; + record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_9, __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_662] = { let __args: [G; IN_662] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_9, __v_1, __v_2]; 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_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_706] = []; - record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __ret: [G; OUT_709] = []; + record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60705,15 +60705,15 @@ fn aiur_fn_706( }) } -const INPUT_SIZE_707: usize = 3; -const IN_707: usize = 3; -const OUT_707: usize = 0; -fn aiur_fn_707( - inp: [G; IN_707], +const INPUT_SIZE_710: usize = 3; +const IN_710: usize = 3; +const OUT_710: usize = 0; +fn aiur_fn_710( + inp: [G; IN_710], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_707], 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]; @@ -60723,17 +60723,17 @@ fn aiur_fn_707( let __v_4: G = __r_arr[1]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_3, __v_3, __v_4]; 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_707] = []; - record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_3, __v_3, __v_4]; 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 __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_2]; 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_703] = { let __args: [G; IN_703] = [__v_2]; 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 __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_3, __v_3, __v_4, __v_5]; 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_708] = { let __args: [G; IN_708] = [__v_3, __v_3, __v_4, __v_5]; 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_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60743,63 +60743,63 @@ fn aiur_fn_707( }) } -const INPUT_SIZE_708: usize = 2; -const IN_708: usize = 2; -const OUT_708: usize = 0; -fn aiur_fn_708( - inp: [G; IN_708], +const INPUT_SIZE_711: usize = 2; +const IN_711: usize = 2; +const OUT_711: usize = 0; +fn aiur_fn_711( + inp: [G; IN_711], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_708], ExecError> { +) -> Result<[G; OUT_711], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0]; 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_703] = { let __args: [G; IN_703] = [__v_0]; 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 __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !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_704] = { let __args: [G; IN_704] = [__v_1, __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 __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() }); } - let __ret: [G; OUT_708] = []; - record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_711] = []; + record.function_queries[711].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 = 0; -fn aiur_fn_709( - inp: [G; IN_709], +const INPUT_SIZE_712: usize = 3; +const IN_712: usize = 3; +const OUT_712: usize = 0; +fn aiur_fn_712( + inp: [G; IN_712], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_709], 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]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0]; 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_703] = { let __args: [G; IN_703] = [__v_0]; 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 __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_4, __v_4, __v_5]; 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_709] = []; - record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_4, __v_4, __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 __ret: [G; OUT_712] = []; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_2]; 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_703] = { let __args: [G; IN_703] = [__v_2]; 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 __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4, __v_4, __v_5, __v_6]; 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_709] = []; - record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_4, __v_4, __v_5, __v_6]; 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_712] = []; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -60809,15 +60809,15 @@ fn aiur_fn_709( }) } -const INPUT_SIZE_710: usize = 55; -const IN_710: usize = 55; -const OUT_710: usize = 0; -fn aiur_fn_710( - inp: [G; IN_710], +const INPUT_SIZE_713: usize = 55; +const IN_713: usize = 55; +const OUT_713: usize = 0; +fn aiur_fn_713( + inp: [G; IN_713], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_710], 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]; @@ -60931,13 +60931,13 @@ fn aiur_fn_710( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_56, __v_2, __v_3]; 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_684] = { let __args: [G; IN_684] = [__v_57, __v_4, __v_5]; 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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_66, __v_15, __v_16]; 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_689] = { let __args: [G; IN_689] = [__v_67, __v_17, __v_18]; 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 __ret: [G; OUT_710] = []; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_56, __v_2, __v_3]; 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_687] = { let __args: [G; IN_687] = [__v_57, __v_4, __v_5]; 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_690] = { let __args: [G; IN_690] = [__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[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_692] = { let __args: [G; IN_692] = [__v_66, __v_15, __v_16]; 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_692] = { let __args: [G; IN_692] = [__v_67, __v_17, __v_18]; 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 __ret: [G; OUT_713] = []; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60952,17 +60952,17 @@ fn aiur_fn_710( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_56, __v_2, __v_3]; 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_686] = { let __args: [G; IN_686] = [__v_57, __v_4, __v_5]; 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_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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_98, __v_51, __v_52]; 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_691] = { let __args: [G; IN_691] = [__v_99, __v_53, __v_54]; 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 __ret: [G; OUT_710] = []; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56, __v_2, __v_3]; 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_689] = { let __args: [G; IN_689] = [__v_57, __v_4, __v_5]; 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_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[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_690] = { let __args: [G; IN_690] = [__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[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_690] = { let __args: [G; IN_690] = [__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[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_690] = { let __args: [G; IN_690] = [__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[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_690] = { let __args: [G; IN_690] = [__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[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_692] = { let __args: [G; IN_692] = [__v_98, __v_51, __v_52]; 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_694] = { let __args: [G; IN_694] = [__v_99, __v_53, __v_54]; 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 __ret: [G; OUT_713] = []; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60977,11 +60977,11 @@ fn aiur_fn_710( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_56, __v_2, __v_3]; 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_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[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_689] = { let __args: [G; IN_689] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_710] = []; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56, __v_2, __v_3]; 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_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[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_692] = { let __args: [G; IN_692] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_713] = []; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -60996,11 +60996,11 @@ fn aiur_fn_710( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_56, __v_2, __v_3]; 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_687] = { let __args: [G; IN_687] = [__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[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_689] = { let __args: [G; IN_689] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_710] = []; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_56, __v_2, __v_3]; 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_690] = { let __args: [G; IN_690] = [__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[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_692] = { let __args: [G; IN_692] = [__v_65, __v_13, __v_14]; 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 __ret: [G; OUT_713] = []; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -61015,11 +61015,11 @@ fn aiur_fn_710( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__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[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_687] = { let __args: [G; IN_687] = [__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[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_20, __v_21]; 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 __ret: [G; OUT_710] = []; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__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[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_690] = { let __args: [G; IN_690] = [__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[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_72, __v_20, __v_21]; 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 __ret: [G; OUT_713] = []; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -61034,10 +61034,10 @@ fn aiur_fn_710( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_710] = []; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_713] = []; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -61052,10 +61052,10 @@ fn aiur_fn_710( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_710] = []; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_713] = []; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -61070,10 +61070,10 @@ fn aiur_fn_710( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_710] = []; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__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[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_64, __v_11, __v_12]; 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 __ret: [G; OUT_713] = []; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -61086,9 +61086,9 @@ fn aiur_fn_710( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_56, __v_2]; 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_710] = []; - record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_56, __v_2]; 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_713] = []; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61105,15 +61105,15 @@ fn aiur_fn_710( }) } -const INPUT_SIZE_711: usize = 4; -const IN_711: usize = 4; -const OUT_711: usize = 0; -fn aiur_fn_711( - inp: [G; IN_711], +const INPUT_SIZE_714: usize = 4; +const IN_714: usize = 4; +const OUT_714: usize = 0; +fn aiur_fn_714( + inp: [G; IN_714], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_711], 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]; @@ -61124,21 +61124,21 @@ fn aiur_fn_711( if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); } - let __ret: [G; OUT_711] = []; - record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_714] = []; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_712: usize = 32; -const IN_712: usize = 32; -const OUT_712: usize = 0; -fn aiur_fn_712( - inp: [G; IN_712], +const INPUT_SIZE_715: usize = 32; +const IN_715: usize = 32; +const OUT_715: usize = 0; +fn aiur_fn_715( + inp: [G; IN_715], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_712], 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]; @@ -61172,7 +61172,7 @@ fn aiur_fn_712( let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[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_684] = { let __args: [G; IN_684] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[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_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; @@ -61231,33 +61231,33 @@ fn aiur_fn_712( let __v_87: G = __r_arr[55]; match __v_32.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_33, __v_34, __v_35, __v_36]; 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 __ret: [G; OUT_712] = []; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_33, __v_34, __v_35, __v_36]; 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 __ret: [G; OUT_715] = []; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_33, __v_34, __v_35]; 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_712] = []; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_33, __v_34, __v_35]; 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 __ret: [G; OUT_715] = []; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_33, __v_34, __v_35]; 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 __ret: [G; OUT_712] = []; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_33, __v_34, __v_35]; 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 __ret: [G; OUT_715] = []; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; 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 __ret: [G; OUT_712] = []; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; 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 __ret: [G; OUT_715] = []; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_33, __v_34]; 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_712] = []; - record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_33, __v_34]; 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 __ret: [G; OUT_715] = []; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61267,15 +61267,15 @@ fn aiur_fn_712( }) } -const INPUT_SIZE_713: usize = 32; -const IN_713: usize = 32; -const OUT_713: usize = 0; -fn aiur_fn_713( - inp: [G; IN_713], +const INPUT_SIZE_716: usize = 32; +const IN_716: usize = 32; +const OUT_716: usize = 0; +fn aiur_fn_716( + inp: [G; IN_716], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_713], 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]; @@ -61316,7 +61316,7 @@ fn aiur_fn_713( let __v_35: G = G::from_u64(0); let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_32, __v_34, __v_35]; 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_36: G = __r_arr[0]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_33, __v_36]; 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_729] = { let __args: [G; IN_729] = [__v_33, __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 __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_38: G = __loaded[0]; @@ -61330,28 +61330,28 @@ fn aiur_fn_713( let __v_46: G = __loaded[8]; let __v_47: G = __loaded[9]; let __v_48: G = __loaded[10]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_36, __v_33, __v_34]; 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_713] = []; - record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_36, __v_33, __v_34]; 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_716] = []; + record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_714: usize = 1; -const IN_714: usize = 1; -const OUT_714: usize = 0; -fn aiur_fn_714( - inp: [G; IN_714], +const INPUT_SIZE_717: usize = 1; +const IN_717: usize = 1; +const OUT_717: usize = 0; +fn aiur_fn_717( + inp: [G; IN_717], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_714], ExecError> { +) -> Result<[G; OUT_717], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_714] = []; - record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_717] = []; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61437,24 +61437,24 @@ fn aiur_fn_714( if (__v_7 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_65.as_canonical_u64() }); } - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_2]; 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 __ret: [G; OUT_714] = []; - record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + 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 __ret: [G; OUT_717] = []; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_715: usize = 0; -const IN_715: usize = 0; -const OUT_715: usize = 0; -fn aiur_fn_715( - inp: [G; IN_715], +const INPUT_SIZE_718: usize = 0; +const IN_718: usize = 0; +const OUT_718: usize = 0; +fn aiur_fn_718( + inp: [G; IN_718], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_715], ExecError> { +) -> Result<[G; OUT_718], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(0); @@ -61590,44 +61590,44 @@ fn aiur_fn_715( if (__v_66 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64() }); } - let __ret: [G; OUT_715] = []; - record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_718] = []; + record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_716: usize = 0; -const IN_716: usize = 0; -const OUT_716: usize = 0; -fn aiur_fn_716( - inp: [G; IN_716], +const INPUT_SIZE_719: usize = 0; +const IN_719: usize = 0; +const OUT_719: usize = 0; +fn aiur_fn_719( + inp: [G; IN_719], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_716], ExecError> { +) -> Result<[G; OUT_719], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = []; 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 __ret: [G; OUT_716] = []; - record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = []; 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 __ret: [G; OUT_719] = []; + record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_717: usize = 1; -const IN_717: usize = 1; -const OUT_717: usize = 0; -fn aiur_fn_717( - inp: [G; IN_717], +const INPUT_SIZE_720: usize = 1; +const IN_720: usize = 1; +const OUT_720: usize = 0; +fn aiur_fn_720( + inp: [G; IN_720], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_717], ExecError> { +) -> Result<[G; OUT_720], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_717] = []; - record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_720] = []; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61872,24 +61872,24 @@ fn aiur_fn_717( if (__v_97 != __v_129) { return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_129.as_canonical_u64() }); } - 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 __ret: [G; OUT_717] = []; - record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + 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 __ret: [G; OUT_720] = []; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_718: usize = 2; -const IN_718: usize = 2; -const OUT_718: usize = 1; -fn aiur_fn_718( - inp: [G; IN_718], +const INPUT_SIZE_721: usize = 2; +const IN_721: usize = 2; +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_718], 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]; @@ -61904,17 +61904,17 @@ fn aiur_fn_718( 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_718] = [__v_9]; - record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_721] = [__v_9]; + record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __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_721] = { let __args: [G; IN_721] = [__v_4, __v_1]; 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_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_718] = [__v_7]; - record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_721] = [__v_7]; + record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61924,15 +61924,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_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_719], ExecError> { +) -> Result<[G; OUT_722], 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 }; @@ -61956,12 +61956,12 @@ fn aiur_fn_719( 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_719] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; - record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_722] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__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_722] = { let __args: [G; IN_722] = [__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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -61979,8 +61979,8 @@ fn aiur_fn_719( 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_719] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_722] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -61990,15 +61990,15 @@ fn aiur_fn_719( }) } -const INPUT_SIZE_720: usize = 1; -const IN_720: usize = 1; -const OUT_720: usize = 8; -fn aiur_fn_720( - inp: [G; IN_720], +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_720], ExecError> { +) -> Result<[G; OUT_723], 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 }; @@ -62015,12 +62015,12 @@ fn aiur_fn_720( 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_720] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_723] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - 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_723] = { let __args: [G; IN_723] = [__v_3]; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -62038,8 +62038,8 @@ fn aiur_fn_720( 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_720] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[720].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)); return Ok(__ret); }, _ => { @@ -62049,15 +62049,15 @@ fn aiur_fn_720( }) } -const INPUT_SIZE_721: usize = 2; -const IN_721: usize = 2; -const OUT_721: usize = 1; -fn aiur_fn_721( - inp: [G; IN_721], +const INPUT_SIZE_724: usize = 2; +const IN_724: usize = 2; +const OUT_724: usize = 1; +fn aiur_fn_724( + inp: [G; IN_724], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_721], 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]; @@ -62067,17 +62067,17 @@ fn aiur_fn_721( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_721] = [__v_1]; - record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_724] = [__v_1]; + record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_4, __v_1]; 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_724] = { let __args: [G; IN_724] = [__v_4, __v_1]; 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_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_721] = [__v_7]; - record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_724] = [__v_7]; + record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62087,15 +62087,15 @@ fn aiur_fn_721( }) } -const INPUT_SIZE_722: usize = 2; -const IN_722: usize = 2; -const OUT_722: usize = 1; -fn aiur_fn_722( - inp: [G; IN_722], +const INPUT_SIZE_725: usize = 2; +const IN_725: usize = 2; +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_722], 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]; @@ -62107,17 +62107,17 @@ fn aiur_fn_722( let __v_6: G = __loaded[4]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_722] = [__v_1]; - record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_725] = [__v_1]; + record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_6, __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_725] = { let __args: [G; IN_725] = [__v_6, __v_1]; 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_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 5] = [__v_7, __v_3, __v_4, __v_5, __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_722] = [__v_9]; - record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_725] = [__v_9]; + record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62127,15 +62127,15 @@ fn aiur_fn_722( }) } -const INPUT_SIZE_723: usize = 8; -const IN_723: usize = 8; -const OUT_723: usize = 1; -fn aiur_fn_723( - inp: [G; IN_723], +const INPUT_SIZE_726: usize = 8; +const IN_726: usize = 8; +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_723], 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]; @@ -62147,8 +62147,8 @@ fn aiur_fn_723( let __v_7: G = inp[7]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_723] = [__v_7]; - record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_726] = [__v_7]; + record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -62169,25 +62169,25 @@ fn aiur_fn_723( 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_723] = { let __args: [G; IN_723] = [__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[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_726] = { let __args: [G; IN_726] = [__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[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_21: G = __r_arr[0]; - let __ret: [G; OUT_723] = [__v_21]; - record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_726] = [__v_21]; + record.function_queries[726].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_723] = [__v_4]; - record.function_queries[723].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); }, _ => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__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[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_726] = { let __args: [G; IN_726] = [__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[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_22: G = __r_arr[0]; - let __ret: [G; OUT_723] = [__v_22]; - record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_726] = [__v_22]; + record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -62201,37 +62201,37 @@ fn aiur_fn_723( }) } -const INPUT_SIZE_724: usize = 1; -const IN_724: usize = 1; -const OUT_724: usize = 1; -fn aiur_fn_724( - inp: [G; IN_724], +const INPUT_SIZE_727: usize = 1; +const IN_727: usize = 1; +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_724], ExecError> { +) -> Result<[G; OUT_727], 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_745] = { let __args: [G; IN_745] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_724] = [__v_4]; - record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_727] = [__v_4]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_725: usize = 1; -const IN_725: usize = 1; -const OUT_725: usize = 8; -fn aiur_fn_725( - inp: [G; IN_725], +const INPUT_SIZE_728: usize = 1; +const IN_728: usize = 1; +const OUT_728: usize = 8; +fn aiur_fn_728( + inp: [G; IN_728], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_725], ExecError> { +) -> Result<[G; OUT_728], 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 }; @@ -62281,12 +62281,12 @@ fn aiur_fn_725( 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_725] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; - record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_728] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_36]; 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_728] = { let __args: [G; IN_728] = [__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 = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -62304,8 +62304,8 @@ fn aiur_fn_725( 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_725] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; - record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_728] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62315,19 +62315,19 @@ fn aiur_fn_725( }) } -const INPUT_SIZE_726: usize = 2; -const IN_726: usize = 2; -const OUT_726: usize = 1; -fn aiur_fn_726( - inp: [G; IN_726], +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_726], 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]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __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]; @@ -62335,8 +62335,8 @@ fn aiur_fn_726( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_726] = [__v_4]; - record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_729] = [__v_4]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62346,15 +62346,15 @@ fn aiur_fn_726( }) } -const INPUT_SIZE_727: usize = 9; -const IN_727: usize = 9; -const OUT_727: usize = 1; -fn aiur_fn_727( - inp: [G; IN_727], +const INPUT_SIZE_730: usize = 9; +const IN_730: usize = 9; +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_727], 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]; @@ -62375,8 +62375,8 @@ fn aiur_fn_727( let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_727] = [__v_10]; - record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_730] = [__v_10]; + record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -62389,10 +62389,10 @@ fn aiur_fn_727( let __v_18: G = __r_arr[5]; let __v_19: G = __r_arr[6]; let __v_20: G = __r_arr[7]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_11, __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[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_730] = { let __args: [G; IN_730] = [__v_11, __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[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_21: G = __r_arr[0]; - let __ret: [G; OUT_727] = [__v_21]; - record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_730] = [__v_21]; + record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62407,15 +62407,15 @@ fn aiur_fn_727( }) } -const INPUT_SIZE_728: usize = 1; -const IN_728: usize = 1; -const OUT_728: usize = 1; -fn aiur_fn_728( - inp: [G; IN_728], +const INPUT_SIZE_731: usize = 1; +const IN_731: usize = 1; +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_728], ExecError> { +) -> Result<[G; OUT_731], 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 }; @@ -62432,17 +62432,17 @@ fn aiur_fn_728( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_728] = [__v_11]; - record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_731] = [__v_11]; + record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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_731] = { let __args: [G; IN_731] = [__v_10]; 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 = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); - let __ret: [G; OUT_728] = [__v_13]; - record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_731] = [__v_13]; + record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62452,15 +62452,15 @@ fn aiur_fn_728( }) } -const INPUT_SIZE_729: usize = 7; -const IN_729: usize = 7; -const OUT_729: usize = 1; -fn aiur_fn_729( - inp: [G; IN_729], +const INPUT_SIZE_732: usize = 7; +const IN_732: usize = 7; +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_729], 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]; @@ -62488,25 +62488,25 @@ fn aiur_fn_729( let __v_19: 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_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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_732] = { let __args: [G; IN_732] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 __ret: [G; OUT_729] = [__v_20]; - record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_732] = [__v_20]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_20: G = (__v_0 - __v_3); match __v_20.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_729] = [__v_4]; - record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_732] = [__v_4]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_732] = { let __args: [G; IN_732] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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_21: G = __r_arr[0]; - let __ret: [G; OUT_729] = [__v_21]; - record.function_queries[729].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); }, } @@ -62520,15 +62520,15 @@ fn aiur_fn_729( }) } -const INPUT_SIZE_730: usize = 9; -const IN_730: usize = 9; -const OUT_730: usize = 45; -fn aiur_fn_730( - inp: [G; IN_730], +const INPUT_SIZE_733: usize = 9; +const IN_733: usize = 9; +const OUT_733: usize = 45; +fn aiur_fn_733( + inp: [G; IN_733], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_730], 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]; @@ -62593,8 +62593,8 @@ fn aiur_fn_730( let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_730] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_733] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __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[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -62607,7 +62607,7 @@ fn aiur_fn_730( 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_730] = { let __args: [G; IN_730] = [__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[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_733] = { let __args: [G; IN_733] = [__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[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_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -62653,8 +62653,8 @@ fn aiur_fn_730( 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_730] = [__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[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_733] = [__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[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62669,15 +62669,15 @@ fn aiur_fn_730( }) } -const INPUT_SIZE_731: usize = 2; -const IN_731: usize = 2; -const OUT_731: usize = 1; -fn aiur_fn_731( - inp: [G; IN_731], +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_731], 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]; @@ -62690,17 +62690,17 @@ fn aiur_fn_731( let __v_7: G = __loaded[5]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_731] = [__v_1]; - record.function_queries[731].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_8: G = G::from_u64(0); - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_7, __v_1]; 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_734] = { let __args: [G; IN_734] = [__v_7, __v_1]; 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_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 6] = [__v_8, __v_3, __v_4, __v_5, __v_6, __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_731] = [__v_10]; - record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_734] = [__v_10]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62710,15 +62710,15 @@ fn aiur_fn_731( }) } -const INPUT_SIZE_732: usize = 1; -const IN_732: usize = 1; -const OUT_732: usize = 8; -fn aiur_fn_732( - inp: [G; IN_732], +const INPUT_SIZE_735: usize = 1; +const IN_735: usize = 1; +const OUT_735: usize = 8; +fn aiur_fn_735( + inp: [G; IN_735], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_732], ExecError> { +) -> Result<[G; OUT_735], 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 }; @@ -62779,12 +62779,12 @@ fn aiur_fn_732( 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_732] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; - record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_735] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_47]; 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_735] = { let __args: [G; IN_735] = [__v_47]; 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_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -62802,8 +62802,8 @@ fn aiur_fn_732( 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_732] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; - record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_735] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62813,15 +62813,15 @@ fn aiur_fn_732( }) } -const INPUT_SIZE_733: usize = 1; -const IN_733: usize = 1; -const OUT_733: usize = 8; -fn aiur_fn_733( - inp: [G; IN_733], +const INPUT_SIZE_736: usize = 1; +const IN_736: usize = 1; +const OUT_736: usize = 8; +fn aiur_fn_736( + inp: [G; IN_736], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_733], ExecError> { +) -> Result<[G; OUT_736], 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 }; @@ -62846,12 +62846,12 @@ fn aiur_fn_733( 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_733] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_736] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_11]; 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_736] = { let __args: [G; IN_736] = [__v_11]; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -62869,8 +62869,8 @@ fn aiur_fn_733( 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_733] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; - record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_736] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62880,15 +62880,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_737: usize = 2; +const IN_737: usize = 2; +const OUT_737: usize = 1; +fn aiur_fn_737( + inp: [G; IN_737], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_734], 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]; @@ -62899,17 +62899,17 @@ fn aiur_fn_734( let __v_5: G = __loaded[3]; 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_737] = [__v_1]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5, __v_1]; 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_737] = { let __args: [G; IN_737] = [__v_5, __v_1]; 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_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_734] = [__v_8]; - record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_737] = [__v_8]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -62919,15 +62919,15 @@ fn aiur_fn_734( }) } -const INPUT_SIZE_735: usize = 9; -const IN_735: usize = 9; -const OUT_735: usize = 34; -fn aiur_fn_735( - inp: [G; IN_735], +const INPUT_SIZE_738: usize = 9; +const IN_738: usize = 9; +const OUT_738: usize = 34; +fn aiur_fn_738( + inp: [G; IN_738], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_735], ExecError> { +) -> Result<[G; OUT_738], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62981,8 +62981,8 @@ fn aiur_fn_735( let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_735] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_738] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -62995,7 +62995,7 @@ fn aiur_fn_735( 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_735] = { let __args: [G; IN_735] = [__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[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_738] = { let __args: [G; IN_738] = [__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[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -63030,8 +63030,8 @@ fn aiur_fn_735( 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_735] = [__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[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_738] = [__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[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63046,15 +63046,15 @@ fn aiur_fn_735( }) } -const INPUT_SIZE_736: usize = 1; -const IN_736: usize = 1; -const OUT_736: usize = 1; -fn aiur_fn_736( - inp: [G; IN_736], +const INPUT_SIZE_739: usize = 1; +const IN_739: usize = 1; +const OUT_739: usize = 1; +fn aiur_fn_739( + inp: [G; IN_739], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_736], ExecError> { +) -> Result<[G; OUT_739], 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 }; @@ -63064,14 +63064,14 @@ fn aiur_fn_736( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_736] = [__v_4]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_739] = [__v_4]; + record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_736] = [__v_4]; - record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_739] = [__v_4]; + record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63081,19 +63081,19 @@ fn aiur_fn_736( }) } -const INPUT_SIZE_737: usize = 2; -const IN_737: usize = 2; -const OUT_737: usize = 3; -fn aiur_fn_737( - inp: [G; IN_737], +const INPUT_SIZE_740: usize = 2; +const IN_740: usize = 2; +const OUT_740: usize = 3; +fn aiur_fn_740( + inp: [G; IN_740], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_737], ExecError> { +) -> Result<[G; OUT_740], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -63103,8 +63103,8 @@ fn aiur_fn_737( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_737] = [__v_4, __v_5, __v_6]; - record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_740] = [__v_4, __v_5, __v_6]; + record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63114,15 +63114,15 @@ fn aiur_fn_737( }) } -const INPUT_SIZE_738: usize = 2; -const IN_738: usize = 2; -const OUT_738: usize = 1; -fn aiur_fn_738( - inp: [G; IN_738], +const INPUT_SIZE_741: usize = 2; +const IN_741: usize = 2; +const OUT_741: usize = 1; +fn aiur_fn_741( + inp: [G; IN_741], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_738], ExecError> { +) -> Result<[G; OUT_741], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63131,8 +63131,8 @@ fn aiur_fn_738( 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_738] = [__v_4]; - record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_741] = [__v_4]; + record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63145,11 +63145,11 @@ fn aiur_fn_738( 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_738] = { let __args: [G; IN_738] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __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_738] = [__v_9]; - record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_741] = [__v_9]; + record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63161,15 +63161,15 @@ fn aiur_fn_738( }) } -const INPUT_SIZE_739: usize = 1; -const IN_739: usize = 1; -const OUT_739: usize = 1; -fn aiur_fn_739( - inp: [G; IN_739], +const INPUT_SIZE_742: usize = 1; +const IN_742: usize = 1; +const OUT_742: usize = 1; +fn aiur_fn_742( + inp: [G; IN_742], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_739], ExecError> { +) -> Result<[G; OUT_742], 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 }; @@ -63212,17 +63212,17 @@ fn aiur_fn_739( match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_739] = [__v_37]; - record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_742] = [__v_37]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_37 + __v_38); - let __ret: [G; OUT_739] = [__v_39]; - record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_742] = [__v_39]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63232,15 +63232,15 @@ fn aiur_fn_739( }) } -const INPUT_SIZE_740: usize = 1; -const IN_740: usize = 1; -const OUT_740: usize = 1; -fn aiur_fn_740( - inp: [G; IN_740], +const INPUT_SIZE_743: usize = 1; +const IN_743: usize = 1; +const OUT_743: usize = 1; +fn aiur_fn_743( + inp: [G; IN_743], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_740], ExecError> { +) -> Result<[G; OUT_743], 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 }; @@ -63253,17 +63253,17 @@ fn aiur_fn_740( match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_740] = [__v_7]; - record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_743] = [__v_7]; + record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; let __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_740] = [__v_9]; - record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_743] = [__v_9]; + record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63273,28 +63273,28 @@ fn aiur_fn_740( }) } -const INPUT_SIZE_741: usize = 2; -const IN_741: usize = 2; -const OUT_741: usize = 1; -fn aiur_fn_741( - inp: [G; IN_741], +const INPUT_SIZE_744: usize = 2; +const IN_744: usize = 2; +const OUT_744: usize = 1; +fn aiur_fn_744( + inp: [G; IN_744], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_741], ExecError> { +) -> Result<[G; OUT_744], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_741] = [__v_0]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_744] = [__v_0]; + record.function_queries[744].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_741] = { let __args: [G; IN_741] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __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]; @@ -63302,8 +63302,8 @@ fn aiur_fn_741( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_741] = [__v_7]; - record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_744] = [__v_7]; + record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63315,15 +63315,15 @@ fn aiur_fn_741( }) } -const INPUT_SIZE_742: usize = 1; -const IN_742: usize = 1; -const OUT_742: usize = 1; -fn aiur_fn_742( - inp: [G; IN_742], +const INPUT_SIZE_745: usize = 1; +const IN_745: usize = 1; +const OUT_745: usize = 1; +fn aiur_fn_745( + inp: [G; IN_745], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_742], ExecError> { +) -> Result<[G; OUT_745], 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 }; @@ -63335,17 +63335,17 @@ fn aiur_fn_742( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_742] = [__v_6]; - record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_745] = [__v_6]; + record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; let __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_742] = [__v_8]; - record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_745] = [__v_8]; + record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63355,15 +63355,15 @@ fn aiur_fn_742( }) } -const INPUT_SIZE_743: usize = 8; -const IN_743: usize = 8; -const OUT_743: usize = 6; -fn aiur_fn_743( - inp: [G; IN_743], +const INPUT_SIZE_746: usize = 8; +const IN_746: usize = 8; +const OUT_746: usize = 6; +fn aiur_fn_746( + inp: [G; IN_746], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_743], ExecError> { +) -> Result<[G; OUT_746], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63373,7 +63373,7 @@ fn aiur_fn_743( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -63384,8 +63384,8 @@ fn aiur_fn_743( 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_743] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; - record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_746] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63395,15 +63395,15 @@ fn aiur_fn_743( }) } -const INPUT_SIZE_744: usize = 9; -const IN_744: usize = 9; -const OUT_744: usize = 1; -fn aiur_fn_744( - inp: [G; IN_744], +const INPUT_SIZE_747: usize = 9; +const IN_747: usize = 9; +const OUT_747: usize = 1; +fn aiur_fn_747( + inp: [G; IN_747], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_744], ExecError> { +) -> Result<[G; OUT_747], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63432,17 +63432,17 @@ fn aiur_fn_744( 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_744] = [__v_23]; - record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_747] = [__v_23]; + record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; let __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_744] = [__v_21]; - record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_747] = [__v_21]; + record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63452,15 +63452,15 @@ fn aiur_fn_744( }) } -const INPUT_SIZE_745: usize = 2; -const IN_745: usize = 2; -const OUT_745: usize = 1; -fn aiur_fn_745( - inp: [G; IN_745], +const INPUT_SIZE_748: usize = 2; +const IN_748: usize = 2; +const OUT_748: usize = 1; +fn aiur_fn_748( + inp: [G; IN_748], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_745], ExecError> { +) -> Result<[G; OUT_748], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63470,17 +63470,17 @@ fn aiur_fn_745( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_745] = [__v_1]; - record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_748] = [__v_1]; + record.function_queries[748].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_745] = { let __args: [G; IN_745] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_745] = [__v_7]; - record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_748] = [__v_7]; + record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63490,28 +63490,28 @@ fn aiur_fn_745( }) } -const INPUT_SIZE_746: usize = 2; -const IN_746: usize = 2; -const OUT_746: usize = 1; -fn aiur_fn_746( - inp: [G; IN_746], +const INPUT_SIZE_749: usize = 2; +const IN_749: usize = 2; +const OUT_749: usize = 1; +fn aiur_fn_749( + inp: [G; IN_749], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_746], ExecError> { +) -> Result<[G; OUT_749], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_746] = [__v_0]; - record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_0]; + record.function_queries[749].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_746] = { let __args: [G; IN_746] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -63521,8 +63521,8 @@ fn aiur_fn_746( let __v_9: G = __loaded[4]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_746] = [__v_9]; - record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_749] = [__v_9]; + record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63534,15 +63534,15 @@ fn aiur_fn_746( }) } -const INPUT_SIZE_747: usize = 8; -const IN_747: usize = 8; -const OUT_747: usize = 6; -fn aiur_fn_747( - inp: [G; IN_747], +const INPUT_SIZE_750: usize = 8; +const IN_750: usize = 8; +const OUT_750: usize = 6; +fn aiur_fn_750( + inp: [G; IN_750], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_747], ExecError> { +) -> Result<[G; OUT_750], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63562,8 +63562,8 @@ fn aiur_fn_747( 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_747] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; - record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_750] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -63584,22 +63584,22 @@ fn aiur_fn_747( 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_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__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[750].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; let __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_748] = { let __args: [G; IN_748] = [__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[748].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__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[751].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_751] = unsafe { *(result.output.as_ptr() as *const [G; OUT_751]) }; __ret } else { aiur_fn_751(__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_747] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; - record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_750] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63609,27 +63609,27 @@ fn aiur_fn_747( 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_747] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; - record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_750] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__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[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__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[750].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; let __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_748] = { let __args: [G; IN_748] = [__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[748].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__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[751].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_751] = unsafe { *(result.output.as_ptr() as *const [G; OUT_751]) }; __ret } else { aiur_fn_751(__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_747] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_750] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63643,15 +63643,15 @@ fn aiur_fn_747( }) } -const INPUT_SIZE_748: usize = 15; -const IN_748: usize = 15; -const OUT_748: usize = 6; -fn aiur_fn_748( - inp: [G; IN_748], +const INPUT_SIZE_751: usize = 15; +const IN_751: usize = 15; +const OUT_751: usize = 6; +fn aiur_fn_751( + inp: [G; IN_751], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_748], ExecError> { +) -> Result<[G; OUT_751], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63670,38 +63670,38 @@ fn aiur_fn_748( let __v_14: G = inp[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_2, __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[749].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_2, __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[752].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_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_748] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; - record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_751] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + record.function_queries[751].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_748] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; - record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_751] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_749: usize = 14; -const IN_749: usize = 14; -const OUT_749: usize = 6; -fn aiur_fn_749( - inp: [G; IN_749], +const INPUT_SIZE_752: usize = 14; +const IN_752: usize = 14; +const OUT_752: usize = 6; +fn aiur_fn_752( + inp: [G; IN_752], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_749], ExecError> { +) -> Result<[G; OUT_752], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63741,8 +63741,8 @@ fn aiur_fn_749( 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_749] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63766,8 +63766,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63795,8 +63795,8 @@ fn aiur_fn_749( 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_749] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63820,8 +63820,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63829,8 +63829,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63840,8 +63840,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63869,8 +63869,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63878,8 +63878,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63889,8 +63889,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63902,8 +63902,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63913,8 +63913,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63946,8 +63946,8 @@ fn aiur_fn_749( 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_749] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63971,8 +63971,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -63980,8 +63980,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -63991,8 +63991,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64020,8 +64020,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64029,8 +64029,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64040,8 +64040,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64053,8 +64053,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64064,8 +64064,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64095,8 +64095,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64124,8 +64124,8 @@ fn aiur_fn_749( 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_749] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64149,8 +64149,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64158,8 +64158,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64169,8 +64169,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64198,8 +64198,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64207,8 +64207,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64218,8 +64218,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64231,8 +64231,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64242,8 +64242,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64275,8 +64275,8 @@ fn aiur_fn_749( 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_749] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64300,8 +64300,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64309,8 +64309,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64320,8 +64320,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64349,8 +64349,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64358,8 +64358,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64369,8 +64369,8 @@ fn aiur_fn_749( 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_749] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64382,8 +64382,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64393,8 +64393,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64428,8 +64428,8 @@ fn aiur_fn_749( 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_749] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64453,8 +64453,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64462,8 +64462,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64473,8 +64473,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64502,8 +64502,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64511,8 +64511,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64522,8 +64522,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64535,8 +64535,8 @@ fn aiur_fn_749( 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_749] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64546,8 +64546,8 @@ fn aiur_fn_749( 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_749] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64579,8 +64579,8 @@ fn aiur_fn_749( 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_749] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64604,8 +64604,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64613,8 +64613,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64624,8 +64624,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64653,8 +64653,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -64662,8 +64662,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64673,8 +64673,8 @@ fn aiur_fn_749( 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_749] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64686,8 +64686,8 @@ fn aiur_fn_749( 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_749] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -64697,8 +64697,8 @@ fn aiur_fn_749( 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_749] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_752] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -68464,6 +68464,21 @@ pub(crate) fn execute_generated( let __out = aiur_fn_749(__inp, record, io_buffer, false)?; return Ok(__out.to_vec()); }, + 750u64 => { + let __inp: [G; IN_750] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_750(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 751u64 => { + let __inp: [G; IN_751] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_751(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 752u64 => { + let __inp: [G; IN_752] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_752(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); },